Search results matching tag 'ASP.NET'

Using Deployment setting on Production Environment

antoniovargas — Tue, 02 Mar 2010 10:02:00 GMT

When i studied for the Microsoft exam (70-562, Microsoft .NET Framework 3.5, ASP.NET Application Development) i found an interesting setting that i didn’t known, the Deployment.

This configuration setting ensures that your application will override important application level settings used when you developed your web application. It will ensure that the following configurations are done:

debug is set to false
page output tracing is disabled
force customErrors to be shown to remote users (it will ensure that the end user only see friendly error messages)

If you want to activate this setting, you need to put the following configuration on the machine.config:

<system.web>

<deployment retail="true"/>

</system.web>

</configuration>

Some references:

The Controls collection cannot be modified because the control contains code blocks (i.e. <% ... %>)

ricardo.costa — Wed, 07 May 2008 09:37:54 GMT

Because I have pages with the markup <%= someVariable%> like

<script type="text/javascript">
            
  function ConfirmCallBack(arg)
  {
    if (arg)
     <%= this._nextPostBack%>
  }

</script>

I get the following error: "The Controls collection cannot be modified because the control contains code blocks (i.e. <% ... %><% ... %>)."

To correct it I had to change from

<%= this._nextPostBack%>

<%# this._nextPostBack%>

and in the PageLoad event add the call to Page's DataBind method

protected void Page_Load(object sender, EventArgs e)
{

...

  Page.DataBind();
}

Codesmith, netTiers and reserved words

ricardo.costa — Tue, 15 Apr 2008 11:05:00 GMT

Started today using Codesmith tools today after a year or so since the last time that I used this great generation template based tool.

I had to generate all the layers of an existent portal and I decided to use the netTiers templates to accomplish this task.

And here are the problems that I had to solve:

In the Entities templates:

I have a table named Entity that conflicts with the auxiliary class of the netTiers templates. It seems that the templates already generate a class called Entity and because there is a table called Entity there was a conflict.

I solved that using the alias text file feature of the templates that allows me to define a alias for any table that I have. So I just inserted a new line in my alias text file like this:

Entity:MyEntity

With this alias, netTiers generated a class for my table named MyEntity that didn't conflict with his own class Entity.

In the Data templates:

I had a table with two foreign keys. But the problem was that the foreign keys were on the same column of the table but referencing two different tables.

The problem was that netTiers generated two methods with the same name and signature GetByColumnForeingKey.

I had to change the schema and use two columns, each one referencing a different column in a different table.

In the Domain templates:

I have views in my database and I had compilation problems with the generated classes for these views.

For each view there are two generated files/classes:

MyView.cs and MyViewServiceBase.generated.cs

Where MyView inherits from MyViewBase. Because MyViewBase doesn't exist there was a compilation problem. I just had to strip the "Service" word from the netTiers templates so the file/class generated was MyViewBase.cs instead of MyViewServiceBase.cs

Another problem was with a table with a "Type" column. This gives this error:

Error 1 An object reference is required for the non-static field, method, or property 'TableBase.Type.get' Domain\TableBase.generated.cs 1394 57 Domain

The generated code was

DeepLoad(entity, false, DeepLoadType.ExcludeChildren, Type.EmptyTypes);

I had to change the template so to genreate

DeepLoad(entity, false, DeepLoadType.ExcludeChildren, System.Type.EmptyTypes);

In the Data.SqlClient templates:

There was an ambiguous table named Parameter. netTiers already creates a class named Parameter so I just had to add another line in my alias text file

Parameter:MyParameter

And finally in the web templates:

There was an ambiguous table named Page. I just had to add another line in my alias text file.

Page:MyPage

Dealing with Memory Pressure problems in MOSS and WSS

misidoro — Mon, 26 Nov 2007 22:29:40 GMT

I just a found another great post about memory management and performance issues on the SharePoint platform. This article defines the concept of "Memory Pressure" and discusses in great detail the most common reasons for memory pressure situations and best practices on how to avoid them. For more details, click here.

Page.EnableEventValidation and “Invalid postback or callback argument” error

misidoro — Mon, 19 Nov 2007 12:39:00 GMT

I developed a custom web part that basically renders a form and submits the entered data into a SharePoint list. The problem I was having is that when the form button was clicked, I got the following error:

"Invalid postback or callback argument. Event validation is enabled
using <pages enableEventValidation="true"/> in configuration or <%@ Page
EnableEventValidation="true" %> in a page. For security purposes, this
feature verifies that arguments to postback or callback events originate
from the server control that originally rendered them. If the data is
valid and expected, use the
ClientScriptManager.RegisterForEventValidation method in order to
register the postback or callback data for validation."

This error message is related to a new security enhancement brought by ASP.NET 2.0 called EventValidation. If enabled (default value), this new feature ensures that ASP.NET will only allow the specific events that are raised on a given control during a postback or callback. The main purpose of this security validation is to reduce the risk of unauthorized postback requests and callbacks (more information on this here).

After some research on the Internet, two main approaches were given:

Set the <pages EnableEventValidation="false" …/> in the web.config or at the page level – This is not a recommended approach due to the associated security risks, since event validation will not be performed and the risk of unauthorized postback requests and callbacks will increase.
Use the Page.ClientScript.RegisterForEventValidation(ctrl. UniqueID) in the control – this approach will register the given control and its events for event validation. This seemed like a good approach since it would allow maintaining the event validation but it didn't solve the problem. Apparently, the internal variable _requestValueCollection of the Page class, is never initialized, so method EnsureEventValidationFieldLoaded will never load the dictionary with UniqueIDs and therefore cannot find the control which is authorized to make postback via RegisterForEventValidation.

After this, I tried a different approach, more successfully. The web part is included in the context of a SharePoint page layout. After analyzing this web page, I found out that it included two nested <form></form> elements. After removing these elements, the form submission started working properly.

Add a custom section to web.config

ricardo.costa — Tue, 23 Oct 2007 22:40:41 GMT

If you have created a custom section like this, and if you want to add it programmatically to web.config then you have to:

Use the WebConfigurationManager class and open the web

Configuration config = WebConfigurationManager.OpenWebConfiguration(path, site);

From MSDN

path

The virtual path to the configuration file.

site

The name of the application Web site, as displayed in IIS configuration.

Create a ConfigurationSectionGroup and add it to the Configuration object

ConfigurationSectionGroup sectionGroup = new ConfigurationSectionGroup();

config.SectionGroups.Add("GROUP_NAME", sectionGroup);

Create a new instance of your section (MyCustomSection) and add it to the section group

MyCustomSection section = new MyCustomSection ();

sectionGroup.Sections.Add("SECTION_NAME", section);

Fill your custom section properties

section.Property1 = "0123456789";

section.Property2 = "Lorem ipsum dolor sit amet";

And save the configuration

config.Save();

If you take a look at your web.config you will see that it was modified programmatically as you specified. I use this technique in the setup process of sites. Cool!

Different web.configs

ricardo.costa — Fri, 25 May 2007 09:16:00 GMT

In the project that I'm currently working I had a problem because my connection strings are different from the other developers: I want to work locally in my SQL Express so the connections strings are different and since we are developing with Visual Source Safe 2005 as the version control system it is not possible to change the file where the connections strings are stored.

The easiest way was not to keep the web.config file under source control but of course that wasn't the desired way because we have lots of settings that we want to keep under source control.

After googling a while I found that the appSettings section in the web.config file of an ASP.NET web application has an attribute - file – that can point to an external file where we can store additional settings.

So my initial web.config file is:

<appSettings

</appSettings>

</connectionStrings>

Of course, when I want to work locally in my SQL Express instance this doesn't work. So I changed the web.config file like this:

<appSettings file="custom.config"

</appSettings>

</connectionStrings>

And my custom.config file is:

<appSettings

</appSettings>

What happens is that the settings in the custom.config file override the settings in the web.config file.

The other developers don't need to have the custom.config files because "the runtime ignores the attribute, if the specified file cannot be found" [msdn].

So I have only the custom.config file that it isn't under source control but that's no problem because I only redefine the name of the connection strings. The actual connection strings are still stored in the web.config file and under source control.

Posting back in a modal popup

rrr — Wed, 23 May 2007 09:44:00 GMT

If you have a server-side form that needs to post back to itself, and that form is in a window made available through window.showModalDialog call, the postback will cause a new, blank window to be shown.

The best way to solve this problem is to include the following tag in the <head/> section of your HTML source:
<base target="_self"/>

Setting the original file name when using Response.BinaryWrite()

ricardo.costa — Thu, 16 Nov 2006 14:15:00 GMT

Imagine you have file saved in a database. Then you have an aspx page that gets that page and sends it back to the user.

If you just simply use Response.BinaryWrite you get the browser's download dialog box and the file's name will be the aspx page's name. If you want to force the original file name you have to add an header to the response like this:

Response.AddHeader("Content-Disposition", "inline;filename=ORIGINAL_FILENAME");

Aprovisionamento de sites no IIS6 usando uma aplicação ASP.NET

misidoro — Mon, 06 Nov 2006 22:33:00 GMT

O exemplo apresentado de seguida permite efectuar a criação de um site no IIS6 a partir de uma template. Esta solução torna-se particularmente útil para cenários em que seja necessário efectuar o aprovisionamento de vários sites com a mesma estrutura, composta tipicamente por um conjunto de directorias virtuais. Para efectuar a criação de uma template de site é apenas necessário, na consola de administração do IIS, exportar a configuração de um site com a estrutura pretendida para ficheiro (para mais detalhes sobre este processo, cliquem aqui). A template obtida é um ficheiro xml, designado por ficheiro de metabase do site, contendo toda a configuração de um site. Para mais detalhes sobre a metabase do IIS6, cliquem aqui.

A solução

A solução apresentada de seguida pode ser decomposta nos seguintes passos:

Criação do novo site
Geração da configuração do novo site com base na configuração do site base
Importação da configuração do novo site

As operações realizadas durante o processo de criação de um site fazem uso de dois scripts de base do IIS, localizados na directoria C:\Windows\System32:

Iisweb.vbs: permite efectuar todas as operações de gestão de um site (criação, remoção, etc). Para mais detalhes, cliquem aqui.
iiscnfg.vbs: permite efectuar as operações de gestão da configuração de um site (exportação e importação de configuração, etc). Para mais detalhes, cliquem aqui.

Criação do novo site

Neste passo, é efectuada a criação do site no IIS. De referir que no processo de criação um site no IIS6, podem ser utilizados três modos de acesso:

Endereço IP – permite a definição de um endereço IP como modo de acesso do site. Deste modo, o porto 80 pode ser usado por mais do que um site desde que sejam usados endereços IP diferentes.
Porto – permite a definição de um porto como modo de acesso do site. Deste modo, tem que ser usado um porto diferente para cada site mas permite o uso do mesmo endereço IP.
Host Header – um host header, tal como o nome indica, é um cabeçalho definido ao nível do site e permite que diversos sites utilizem o mesmo porto para o mesmo endereço IP. Exemplos de host headers são “www.create.pt” ou “blogit.create.pt” (o URL que se pretende para o acesso externo ao site sem “http//”). Um pedido HTTP chega ao servidor web e o utilizador é redireccionado para o site correcto com base no URL. Como nota final, de referir que usando host headers, é necessário criar uma entrada no DNS por cada site criado a apontar para o endereço IP externo do servidor web.

Para mais detalhes sobre o processo de criação de um site no IIS6, cliquem aqui.

O seguinte método é responsável pela criação do site. O site, nesta fase, não é iniciado, apenas o sendo no final.

//constantes usadas ao longo dos exemplos
private const string IIS_WEB_COMMAND = @"C:\WINDOWS\system32\iisWeb.vbs";
private const string IIS_CONFIG_COMMAND = @"C:\WINDOWS\system32\iisCnfg.vbs";
private const string WINDOWS_COMMAND = "cmd";
private const string SITEPATH_REGULAR_EXPRESSION = @"W3SVC/\d*";
 

private int CreateSite(string webSiteHomeDirectory, string siteName, string ip, string port, string hostHeader)
{
    Process process = new Process();
 
    process.EnableRaisingEvents = false;
 
    //criar site mas não arrancá-lo
    //iisweb /create <directoria> <nome> /donstart
    StringBuilder commandArguments = new StringBuilder(String.Format(@" /create {0} {1} /dontstart", webSiteHomeDirectory, siteName));
 
    //modo de acesso por endereço IP
    if (ip != null && ip.Trim().Length > 0)
        commandArguments.Append(String.Format(" /i {0}", ip));
 
    //modo de acesso por porto
    if (port != null && port.Trim().Length > 0)
        commandArguments.Append(String.Format(" /b {0}", port));
 
    //modo de acesso por host header
    if (hostHeader != null && hostHeader.Trim().Length > 0)
        commandArguments.Append(String.Format(" /d {0}", hostHeader));
 
    //assignar o script a correr
    process.StartInfo.FileName = IIS_WEB_COMMAND;
    process.StartInfo.Arguments = commandArguments.ToString();
    /iniciar o processo
    process.Start();
    process.WaitForExit();
 
    //retornar código de execução do processo. Retorna 0 se tudo correr bem.
    return process.ExitCode;
}

Ao longo dos exemplos, é utilizada a classe System.Diagnostics.Process para efectuar a execução dos scripts do IIS. Para mais detalhes sobre esta classe, cliquem aqui.

Geração da configuração do novo site com base na configuração do site base

Neste passo, é lida o ficheiro de metabase do site base e gerado a partir deste, o ficheiro de configuração do novo site. As alterações a efectuar à configuração base são compostos tipicamente por:

Alteração do ID do site para o ID do novo site
Alteração da directoria do site (e das directorias virtuais se existirem) para as do novo site
Alterar o nome do site para o do novo site
Alterar o host header para o do novo site

O seguinte método é responsável pela geração do ficheiro de metabase do novo site. Este ficheiro será posteriormente utilizado para importar a configuração do novo site. De referir que tratando-se o ficheiro de metabase um ficheiro xml, foi utilizada a classe XmlDocument para efectuar a manipulação do mesmo.

private string CreateSiteTemplateXml(string xmlConfigPath, string masterWebID, string createdWebID, string siteName, string hostHeader)
{
    XmlDocument xmlDocument = new XmlDocument();
    //ler ficheiro de metabase do site base
    xmlDocument.Load(xmlConfigPath);
 
    //seleccionar elemento xml IISWebServer da metabase
    XmlNodeList xmlNodeList = xmlDocument.DocumentElement.SelectNodes(“./MBProperty/IIsWebServer”);
 
    //substituir host header
    foreach(XmlNode xmlNode in xmlNodeList)
    {
        xmlAttribute = XmlHelper.GetAttribute(xmlNode.Attributes, “ServerBindings”);
        string serverBinding = xmlAttribute.Value;
        string [] serverBindings = serverBinding.Split(':');
        string oldHostHeader = serverBindings[serverBindings.Length - 1];
        xmlAttribute.Value = xmlAttribute.Value.Replace(oldHostHeader, hostHeader);
    }
 
    //substituir nome site
    foreach(XmlNode xmlNode in xmlNodeList)
    {
        xmlAttribute = XmlHelper.GetAttribute(xmlNode.Attributes, “ServerComment”);
        xmlAttribute.Value = xmlAttribute.Value.Replace(xmlAttribute.Value, siteName);
    }
 
    //seleccionar elemento xml IIsWebVirtualDir da metabase
    xmlNodeList = xmlDocument.DocumentElement.SelectNodes(“./MBProperty/IIsWebVirtualDir”);
 
    foreach(XmlNode xmlNode in xmlNodeList)
    {
        //substituir atributo AppRoot com o id do novo site
        xmlAttribute = XmlHelper.GetAttribute(xmlNode.Attributes, “AppRoot”);
        xmlAttribute.Value = xmlAttribute.Value.Replace(masterWebID, createdWebID);
    }
 
    //substituir directorias do site (existe um elemento IIsWebVirtualDir para a root e para cada directoria virtual). Este exemplo assume que os nomes das directorias do site irão conter o id do site no IIS, sendo substituido o id do site base pelo id do novo site. Ex: C:\inetpub\wwwroot\site<idsitebase> -> C:\inetpub\wwwroot\site<idsitenovo>
    foreach(XmlNode xmlNode in xmlNodeList)
    {
        xmlAttribute = XmlHelper.GetAttribute(xmlNode.Attributes, “Path”);
        xmlAttribute.Value = xmlAttribute.Value.Replace(masterWebID, createdWebID);
    }
 
    //gerar ficheiro metabase novo site
    string newPath = String.Format("{0}{1}.xml", xmlConfigPath.Replace(".xml", String.Empty), createdWebID.Replace(Constants.IISWebSiteIdentifierPrefix, String.Empty));
 
    xmlDocument.Save(newPath);
 
    //retornar caminho para ficheiro metabase do novo site
    return newPath;
}

Importação da configuração do novo site

Neste passo, é efectuada a importação da configuração criada no passo anterior. O seguinte método e responsável por esta operação.

private int ImportSiteConfiguration(string xmlConfigPath, string masterWebID, string createdWebID)
{
     Process process = new Process();
 
     process.EnableRaisingEvents=false;
 
     string commandArguments = String.Format(@" /import /f ""{0}"" /sp /LM/{1}/root /dp /LM/{2}/root /children", xmlConfigPath, masterWebID, createdWebID);
 
     process.StartInfo.FileName = IIS_CONFIG_COMMAND;
     process.StartInfo.Arguments = commandArguments;
     process.Start();
     process.WaitForExit();
 
     return process.ExitCode;
}

O processo de criação do site

O método seguinte efectua a chamada a cada uma dos métodos anteriores e alguns métodos auxiliares para efectuar o processo de criação do site.

public void CreateNewWebSite(string webSiteHomeDirectory, string webSiteBackOfficeFolder, string siteName, 
            string ip, string port, string hostHeader)
{
    //criar site
    int createSiteResult = CreateSite(webSiteHomeDirectory, siteName, null, null, hostHeader);
    if (createSiteResult == 0) //criação site ok
    {
        //obter id do novo site
        string createdSiteID = GetSiteID(siteName);
        //gerar ficheiro configuração novo site
        string xmlConfigPath = CreateSiteTemplateXml(webSiteHomeDirectory, webSiteBackOfficeFolder, Settings.MasterWebSiteXmlConfigurationPath, 
        Settings.MasterWebSiteID, createdSiteID, siteName, hostHeader);
        //importar configuraçao novo site
        int importSiteResult = ImportSiteConfiguration(xmlConfigPath, Settings.MasterWebSiteID, createdSiteID);
        if (importSiteResult == 0) //importação ok
            StartSite(siteName);
    }
}

Outros Métodos Utilizados

Foram ainda utilizados os seguintes métodos:

GetSiteID: método que obtém o id do site a partir do nome.

private string GetSiteID(string siteName)
{
    string commandToExecute = String.Format(@"{0} /query {1}", IIS_WEB_COMMAND, siteName);
 
    string commandResult = RunShellCommand(commandToExecute);
    string siteID = GetRegularExpressionResult(SITEPATH_REGULAR_EXPRESSION, commandResult);
 
    return siteID;
}

RunShellCommand: método que executa um comando externo e obtém o resultado da sua execução.

private string RunShellCommand(string shellCommandToExecute)
{
    Process process = new Process();
 
    process.EnableRaisingEvents=false;
 
    //obter nome ficheiro temporário                
    string tempFileName = String.Format(@"{0}\{1}.txt", Settings.WebSiteCreationTempFolder, DateTime.Now.ToString(FILE_DATETIME_FORMAT));
 
    //executar comando e escrever resultado para ficheiro
    string commandArguments = String.Format(@" /c {0} > {1}", shellCommandToExecute, tempFileName);
 
    process.StartInfo.FileName = WINDOWS_COMMAND;
    process.StartInfo.Arguments = commandArguments;
    process.Start();
    process.WaitForExit();
 
    //ler resultados de ficheiro temporário
    StreamReader streamReader = new StreamReader(tempFileName);
    string commandResults = streamReader.ReadToEnd();
 
    streamReader.Close();
 
    //apagar ficheiro temporário
    File.Delete(tempFileName);
 
    //devolver resultado
    return commandResults;
}

GetRegularExpressionResult: método que aplica uma expressão regular a uma string.

private string GetRegularExpressionResult(string pattern, string inputString)
{
    Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);
    MatchCollection matches = regex.Matches(inputString);
 
    return matches.Count == 1 ? matches[0].Value : String.Empty;
}

StartSite: método que inicia o site.

public void StartSite(string siteName)
{
    Process new Process();
 
    process.EnableRaisingEvents=false;
 
    string commandArguments = String.Format(@" /start {0} ", siteName);
 
    process.StartInfo.FileName = IIS_WEB_COMMAND;
    process.StartInfo.Arguments = commandArguments;
    process.Start();
    process.WaitForExit();
}

Segurança

Existem questões de segurança associadas à criação de sites no IIS6 a partir de uma aplicação ASP.NET. Por omissão, uma aplicação ASP.NET a correr sobre IIS6, é executada usando uma conta de serviço com permissões muito restritas (conta “Network Service”). Para se criar um site no IIS, é necessário ter permissões de administração. Qualquer solução para resolver este problema implica riscos em termos de segurança, sendo o objectivo encontrar uma solução que mitigue estes riscos. Uma solução possível é a criação de um web service que fica responsável pela criação de sites. Este web service seria colocado no IIS numa segunda Web Application a correr numa Application Pool executada com uma conta de serviço com permissões de administração. Desta forma, a aplicação ASP.NET continuaria a correr com a conta de serviço de permissões restritas, sendo a criação de sites a única operação a correr com permissões de administração. Outras medidas de segurança podem ser implementadas, encontrando-se entre elas efectuar a restrição do acesso ao web service, de forma a que possa ser chamado apenas a partir da máquina onde se encontra a aplicação ASP.NET.

Resumo

A solução aqui apresentada permite efectuar a criação de sites no IIS6 a partir de uma template de site usando uma aplicação ASP.NET. É uma solução bastante flexível, na medida em que pode ser usada para efectuar o aprovisionamento de sites a partir de qualquer template. Para tal, basta criar um ficheiro xml de metabase de um site, resultado da exportação da configuração de um site para ficheiro.