this blog covers all the Faqs related to .net technologies like asp.net,vb.net,c#.net,ajax,javascript and sqlserver2005.
Feb 29, 2008
Registering an Assembly in the GAC
Registering an Assembly in the GAC
1) Create an assembly key file Use the sn.exe tool to create a key file: sn -k StrongNameFile.snk If your path environment variables aren't set, you'll have to go to the C:\Program Files\Microsoft.NET\FrameworkSDK\Bin\ directory to run sn.exe) The filename "StrongNameFile.snk" can be any name you want. 2) Edit your assembly Now you have to add a tag which will link your assembly key to the assembly: using System.Reflection; [assembly:AssemblyKeyFile("StrongNameFile.snk")] Normally this is done in the utility AssemblyInfo.cs (vb) file.
3) Add your assembly to the GAC gacutil /i AssemblyFileName.dll To uninstall this assembly from the GAC, use the command: gacutil /u AssemblyFileName
4) (Opional) Add your assembly to machine.config Locate the tag (for web apps,under ////) Between the tags, enter: You can get the information for the assembly attribute, by running the gacutil /l command which will return a list of all the assemblies in the GAC. You will have to look for the one you just added and copy the entire line (less the Custom=XXX part at the end). At this point, you will be able to place this directive in your aspx pages. <%@Import Namespace="YourNamespace"%> or, you can set a reference in the Visual Studio IDE as you would with other GAC Assemblies.
regasm.exe, regsvr32.exe,tlbimp.exe and tlbexp.exe
difference among regasm.exe, regsvr32.exe,tlbimp.exe and tlbexp.exe
The difference between regasm and regsvr32: regasm.exe is used for registering an assembly so that a com client can access its classes and uses them like a com class. regasm.exe is used to create COM Callable Wrapper (CCW) around .NET assemblies. .NET managed assemblies(EXEs, DLLs) are different from COM DLLs (which are unmanaged, ie. they interact with the OS directly). So to register an unmanaged DLL we use regsvr32.exe. But if wehave a managed .NET assembly and we want to use it with COM components to use it as if it were a COM assembly, then we need to use regasm.exe. Regasm.exe creates a type library as well as registers it whereas tlbexp.exe only creates a CCW but does not register it. Tlbimp.exe: Tlbimp.exe (Type Library Importer) is used to create a Runtime Callable Wrapper around a COM component so that the unmanaged COM library can be used in .NET. When do we use Tlbimp and not regasm or regsvr32?
Tlbexp.exe generates a type library that contains definitions of the types defined in the assembly. Applications such as Visual Basic 6.0 can use the generated type library to bind to the .NET types defined in the assembly. The entire assembly is converted at once. You cannot use Tlbexp.exe to generate type information for a subset of the types defined in an assembly. You cannot use Tlbexp.exe to produce a type library from an assembly that was imported using the Type Library Importer (Tlbimp.exe). Instead, you should refer to the original type library that was imported with Tlbimp.exe. You can export a type library from an assembly that references assemblies that were imported using Tlbimp.exe. Tlbexp.exe generates a type library but does not register it. This is in contrast to the Assembly Registration tool (Regasm.exe), which both generates and registers a type library. To generate and register a type library with COM, use Regasm.exe. Type Library Importer Tlbimp.exe performs conversions on an entire type library at one time. You cannot use the tool to generate type information for a subset of the types defined within a single type library. Happy Programming.
A foreign key (FK) is a column or combination of columns used to establish and enforce a link between the data in two tables. A link is created between two tables by adding the column or columns that hold one table's primary key values to the other table. This column becomes a foreign key in the second table.
You can create a foreign key by defining a FOREIGN KEY constraint when you create or alter a table.
For example, the titles table in the pubs database has a link to the publishers table because there is a logical relationship between books and publishers. The pub_id column in the titles table matches the primary key column of the publishers table. The pub_id column in the titles table is the foreign key to the publishers table.
A FOREIGN KEY constraint does not have to be linked only to a PRIMARY KEY constraint in another table; it can also be defined to reference the columns of a UNIQUE constraint in another table. A FOREIGN KEY constraint can contain null values; however, if any column of a composite FOREIGN KEY constraint contains null values, then verification of the FOREIGN KEY constraint will be skipped. Note A FOREIGN KEY constraint can reference columns in tables in the same database or within the same table (self-referencing tables), for example, an employee table that contains three columns: employee_number, employee_name, and manager_employee_number. Because the manager is an employee too, there is a foreign key relationship from the manager_employee_number column to the employee_number column. Although the primary purpose of a FOREIGN KEY constraint is to control the data that can be stored in the foreign key table, it also controls changes to data in the primary key table. For example, if the row for a publisher is deleted from the publishers table, and the publisher's ID is used for books in the titles table, the relational integrity between the two tables is broken; the deleted publisher's books are orphaned in the titles table without a link to the data in the publishers table. A FOREIGN KEY constraint prevents this situation. The constraint enforces referential integrity by ensuring that changes cannot be made to data in the primary key table if those changes invalidate the link to data in the foreign key table. If an attempt is made to delete the row in a primary key table or to change a primary key value, the action will fail if the deleted or changed primary key value corresponds to a value in the FOREIGN KEY constraint of another table. To change or delete a row in a FOREIGN KEY constraint successfully, you must first either delete the foreign key data in the foreign key table or change the foreign key data in the foreign key table, thereby linking the foreign key to different primary key data. A FOREIGN KEY constraint is a candidate for an index because: Changes to PRIMARY KEY constraints are checked with FOREIGN KEY constraints in related tables. Foreign key columns are often used in join criteria when the data from related tables is combined in queries by matching the column(s) in the FOREIGN KEY constraint of one table with the primary or unique key column(s) in the other table. An index allows Microsoft® SQL Server™ 2000 to find related data in the foreign key table quickly. However, creating this index is not a requirement. Data from two related tables can be combined even if no PRIMARY KEY or FOREIGN KEY constraints are defined between the tables, but a foreign key relationship between two tables indicates that the two tables have been optimized to be combined in a query that uses the keys as its criteria.
Using Enterprise DAAB from ASP.NET 2.0 project Enterprise Library and .Net 2.0
Error parsing application configuration file at line 47. Type '{http://www.microsoft.com/practices/enterpriselibrary/08-31-2004/configuration}ReadOnlyConfigurationSectionData' is not found in Schema. Please correct before processeding. (You might rename the current web.config and add a new one.)
I tossed up a quick example of using the Enterprise Library Configuration Application Block in your applications, and thought I would give an example of using the Cache Application Block as well. In this case, I am actually using the two application blocks together so we can seem them side-by-side. As always, the code will run in Snippet Compiler, but you need to download and install the Enterprise Library and move over the appropriate DLL's shown in the directory.
In this example, I am using the XML File Storage Provider to save my configuration settings in my sitesettings.config file and using the default storage provider for caching, called the NullBackingStore, which stores the cache information into a Hashtable in memory.
This time when I run the Enterprise Library Configuration tool I need to add both the Caching Application Block and Configuration Application Block to my application (shown below). I keep the default settings, but I do have to specify that sitesettings.config will be the XML file to store my global application settings. If you don't do this, the application will toss an error reminding you to do so.
At first I was a bit confused as to why there is an XML File Storage Provider and XML Serializer Transformer under cachingConfiguration. I didn't add it. It turns out that there is a separate XML file, called by default cachingConfiguration.config, created to store the caching configuration information. It specifies that I am using the NullBackingStore as well as a few other settings.
Here is the code that reads and writes to both the configuration file and cache for testing:
Although the configuration settings might be a bit ugly in the backend, the code is pretty straight forward. I have added comments above so you can see what is happening. Here are the configuration files:
As you can see, there is certainly a lot of flexiblity with the Enterprise Library as literally you could change the configuration in the backend to specify different storage providers and theoretically never change a single line of code. There has got to be some price to this flexiblity, which is a couple of XML files to specify settings. It looks a bit daunting at first if you aren't used to XML and the plug-in type architecture, but by playing with it more and more one can get comfortable with it pretty quickly.
Delegates in C# are like functions pointers in C/C++. A multi cast delegate can refer to several methods. A delegate can be used to invoke a method, the call to which can only be resolved or determined at runtime. This article discusses what delegates are and how they can be used in C# with lucid code examples.
What are delegates and why are they required?
Delegates are function pointers in C# that are managed and type safe and can refer to one or more methods that have identical signatures. Delegates in C# are reference types. They are type safe, managed function pointers in C# that can be used to invoke a method that the delegate refers to. The signature of the delegate should be the same as the signature of the method to which it refers. According to MSDN, "A delegate in C# is similar to a function pointer in C or C++. Using a delegate allows the programmer to encapsulate a reference to a method inside a delegate object. The delegate object can then be passed to code which can call the referenced method, without having to know at compile time which method will be invoked. Unlike function pointers in C or C++, delegates are object-oriented, type-safe, and secure." C# provides support for Delegates through the class called Delegate in the System namespace. Delegates are of two types. Single-cast delegates Multi-cast delegates A Single-cast delegate is one that can refer to a single method whereas a Multi-cast delegate can refer to and eventually fire off multiple methods that have the same signature. The signature of a delegate type comprises are the following. The name of the delegate The arguments that the delegate would accept as parameters The return type of the delegate A delegate is either public or internal if no specifier is included in its signature. Further, you should instantiate a delegate prior to using the same. The following is an example of how a delegate is declared. Listing 1:Declaring a delegate public delegate void TestDelegate(string message); The return type of the delegate shown in the above example is "void" and it accepts a string argument. Note that the keyword "delegate" identifies the above declaration as a delegate to a method. This delegate can refer to and eventually invoke a method that can accept a string argument and has a return type of void, i.e., it does not return any value. You can use a delegate to make it refer to and invoke a method that has identical signature as the delegate only. Even if you are using multi-cast delegates, remember that you can use your delegate to refer to and then fire off multiple methods that have identical signatures only. A delegate should always be instantiated before it is used. The following statement in Listing 2 shows how you can instantiate a delegate. Listing 2: Instantiating a delegate TestDelegate t = new TestDelegate(Display); Implementing Delegates in C# This section illustrates how we can implement and use delegates in C#. The following is an example of a delegate that is used to refer to a method of identical signature as the delegate and eventually invoke the method using the delegate. Listing 3: Implementing a single-cast delegate using System;
public delegate void TestDelegate(string message); //Declare the delegate class Test { public static void Display(string message) { Console.WriteLine("The string entered is : " + message); } static void Main() { TestDelegate t = new TestDelegate(Display); //Instantiate the delegate Console.WriteLine("Please enter a string"); string message = Console.ReadLine(); t(message); //Invoke the delegate Console.ReadLine(); } }
Refer to the code in Listing 3 above. Note how the delegate has been instantiated. The delegate should be passed the method name as argument when instantiating it to indicate the method that it would be referring to. Further, note that the signature of the delegate "TestDelegate" and the method that it refers to, i.e., "Display", have identical signatures. You can also assign the references of multiple methods to a delegate and use it to invoke multiple methods. Such a delegate is called a multi-cast delegate as multiple method references are cast to it and then the delegate is used to invoke these methods. The following code example illustrates how a multi-cast delegate can be implemented and used. Listing 4: Implementing a multi-cast delegate using System;
public delegate void TestDelegate(); class Test { public static void Display1() { Console.WriteLine("This is the first method"); } public static void Display2() { Console.WriteLine("This is the second method"); } static void Main() { TestDelegate t1 = new TestDelegate(Display1); TestDelegate t2 = new TestDelegate(Display2); t1 = t1 + t2; // Make t1 a multi-cast delegate t1(); //Invoke delegate Console.ReadLine(); } }
On execution of the above program shown in code Listing IV, the following message is displayed: This is the first method This is the second method Note how we have used the delegate instance t1 as a multi-cast delegate by assigning the references of both t1 and t2 to it.
Delegate is type which holds the method(s) reference in an object. It is also reffered as a type safe function pointers.
Advantages:
Encapsulating the method's call from caller.
Effective use of Delegat improves the performance of application.
Used to call a method asynchronously. Declaration: public delegate type_of_delegate delegate_name() Example : public delegate int mydelegate(int delvar1,int delvar2) Note: you can use delegeate without parameter or with parameter list. you should follow the same syntax as in the method. (if you are reffering the method with two int parameters and int return type the delegate which you are declaring should be the same format.This is how it is reffered as type safe function pointer) Sample Program using Delegate :
public delegate double Delegate_Prod(int a,int b); class Class1 { static double fn_Prodvalues(int val1,int val2) { return val1*val2; } static void Main(string[] args) { //Creating the Delegate Instance Delegate_Prod delObj = new Delegate_Prod(fn_Prodvalues); Console.Write("Please Enter Values"); int v1 = Int32.Parse(Console.ReadLine()); int v2 = Int32.Parse(Console.ReadLine()); //use a delegate for processing double res = delObj(v1,v2); Console.WriteLine ("Result :"+res); Console.ReadLine(); } }
Explanation: Here I have used a small program which demonstrates the use of delegate. The delegate "Delegate_Prod" is declared with double return type and which accepts only two interger parameters. Inside the Class the method named fn_Prodvalues is defined with double return type and two integer parameters.(The delegate and method is having the same signature and parameters type) Inside the Main method the delegate instance is created and the function name is passed to the delegae instace as following. Delegate_Prod delObj = new Delegate_Prod(fn_Prodvalues); After this we are accepting the two values from the user and passing those values to the delegate as we do using method . delObj(v1,v2); Here delegate object encapsulates the method functionalities and return the result as we specified in the method. Multicast DelegateIt is a Delegate which holds the reference of more than one methods.Multicast delegates must contain only methods that return void, else there is a run-time exception. Simple Program using Multicast Delegate
delegate void Delegate_Multicast(int x, int y); Class Class2 {static void Method1(int x, int y) { Console.WriteLine("You r in Method 1");}static void Method2(int x, int y) { Console.WriteLine("You r in Method 2");}public static void Main() { Delegate_Multicast func = new Delegate_Multicast(Method1); func += new Delegate_Multicast(Method2); func(1,2); // Method1 and Method2 are called func -= new Delegate_Multicast(Method1); func(2,3); // Only Method2 is called} }
Explanation: In the above example you can see that two methods are defined named method1 and method2 whchi takes two integer parameters and return type as void. In the main method the Delegate object is created using the following statement Delegate_Multicast func = new Delegate_Multicast(Method1); Then the Delegate is added using the += operator and removed using -= operator.
This code demonstrates how you can pass data from one form to another using a delegate. The advantage of using a delegate is that the form from which you want to send the data, doesn't need to know anything about the form that it's sending its data to. This way, you can reuse the same form in other forms or applications.
Details
This is form 1. From this form we display form 2. And from form 2 we send a TextBox back to form 1.
And the code for form 1:
private void btnForm1_Click(object sender, System.EventArgs e) { // Create an instance of form 2 Form2 form2 = new Form2();
// Create an instance of the delegate form2.passControl = new Form2.PassControl(PassData);
// Show form 2 form2.Show(); }
private void PassData(object sender) { // Set de text of the textbox to the value of the textbox of form 2 txtForm1.Text = ((TextBox)sender).Text; }
Form 2 sends the TextBox back to form 1:
public class Form2 : System.Windows.Forms.Form { // Define delegate public delegate void PassControl(object sender);
// Create instance (null) public PassControl passControl;
Of course, using the delegate, you can not only send back the textbox, but other controls, variables or even the form itself, because they are all objects. I hope this is useful.
Temporary Tables The simple answer is yes you can. Let look at a simple CREATE TABLE statement: CREATE TABLE #Yaks ( YakID int, YakName char(30) ) You'll notice I prefixed the table with a pound sign (#). This tells SQL Server that this table is a local temporary table. This table is only visible to this session of SQL Server. When I close this session, the table will be automatically dropped. You can treat this table just like any other table with a few exceptions. The only real major one is that you can't have foreign key constraints on a temporary table. The others are covered in Books Online. Temporary tables are created in tempdb. If you run this query: CREATE TABLE #Yaks ( YakID int, YakName char(30) ) select name from tempdb..sysobjects where name like '#yak%' drop table #yaks You'll get something like this: name ------------------------------------------------------------------------------------ #Yaks_________________________ . . . ___________________________________00000000001D (1 row(s) affected) except that I took about fifty underscores out to make it readable. SQL Server stores the object with a some type of unique number appended on the end of the name. It does all this for you automatically. You just have to refer to #Yaks in your code. If two different users both create a #Yaks table each will have their own copy of it. The exact same code will run properly on both connections. Any temporary table created inside a stored procedure is automatically dropped when the stored procedure finishes executing. If stored procedure A creates a temporary table and calls stored procedure B, then B will be able to use the temporary table that A created. It's generally considered good coding practice to explicitly drop every temporary table you create. If you are running scripts through SQL Server Management Studio or Query Analyzer the temporary tables are kept until you explicitly drop them or until you close the session. Now let's get back to your question. The best way to use a temporary table is to create it and then fill it with data. This goes something like this:CREATE TABLE #TibetanYaks( YakID int, YakName char(30) ) INSERT INTO #TibetanYaks (YakID, YakName) SELECT YakID, YakName FROM dbo.Yaks WHERE YakType = 'Tibetan' -- Do some stuff with the table drop table #TibetanYaks Obviously, this DBA knows their yaks as they're selecting the famed Tibetan yaks, the Cadillac of yaks. Temporary tables are usually pretty quick. Since you are creating and deleting them on the fly, they are usually only cached in memory. Table Variables If you are using SQL Server 2000 or higher, you can take advantage of the new TABLE variable type. These are similar to temporary tables except with more flexibility and they always stay in memory. The code above using a table variable might look like this:DECLARE @TibetanYaks TABLE ( YakID int, YakName char(30) ) INSERT INTO @TibetanYaks (YakID, YakName) SELECT YakID, YakName FROM dbo.Yaks WHERE YakType = 'Tibetan' -- Do some stuff with the table Table variables don't need to be dropped when you are done with them. Which to Use If you have less than 100 rows generally use a table variable. Otherwise use a temporary table. This is because SQL Server won't create statistics on table variables. If you need to create indexes on it then you must use a temporary table. When using temporary tables always create them and create any indexes and then use them. This will help reduce recompilations. The impact of this is reduced starting in SQL Server 2005 but it's still a good idea. Answering the Question And all this brings us back to your question. The final answer to your question might look something like this: DECLARE @TibetanYaks TABLE ( YakID int, YakName char(30) ) INSERT INTO @TibetanYaks (YakID, YakName) SELECT YakID, YakName FROM dbo.Yaks WHERE YakType = 'Tibetan' UPDATE @TibetanYaks SET YakName = UPPER(YakName) SELECT * FROM @TibetanYaks Global Temporary Tables You can also create global temporary tables. These are named with two pound signs. For example, ##YakHerders is a global temporary table. Global temporary tables are visible to all SQL Server connections. When you create one of these, all the users can see it. These are rarely used in SQL Server. Summary That shows you an example of creating a temporary table, modifying it, and returning the values to the calling program. I hope this gives you what you were looking for.
2.1 What is ASP.NET? ASP.NET is a programming framework built on the common language runtime that can be used on a server to build powerful Web applications. For more details refer What is ASP.NET ASP.NET OverView
Faqs on asp.net,c#,vb.net and sqlserver2005
Faqs Feed
