L'extraction de données aléatoires de base de données

L'extraction de données aléatoires de base de données MySQL, PostgreSQL, SQL Server, IBM DB2 et Oracle

Tout ce que nous savons comment extraire des données de base de données et d'organiser à accomplir un certain besoin.Mais il pourrait y avoir des situations où nous avons besoin pour afficher des lignes aléatoires (signifie, les données seront de toute ligne de table particulière indépendamment les numéros de série).Une fois, je face à cette situation lorsque j'essayais de construire un site Web où un programme « Link Exchange » était là, où tous les liens sont enregistrées dans la base de données et je devais montrer seulement quatre liens à la fois, et lorsque la page va être actualisée, les liens seront modifiés et afficheront un autre quatre liens et ces liens peuvent être de toute ligne de la table qui contient ces liens.Donc, j'ai fait avec SQLServer que je travaillais avec SQLServer, mais ici je de mentionner la syntaxe de la requête pour extraire des données aléatoires pour base MySQL, PostgreSQL, SQL Server, IBM DB2 et Oracle, ainsi:-

L'extraction des données aléatoires avec MySQL :

Colonne SELECT FROM table
ORDRE PAR RAND()
LIMITE DE 1

L'extraction des données aléatoires avec PostgreSQL :

Colonne SELECT FROM table
ORDRE PAR RANDOM()
LIMITE DE 1

L'extraction des données aléatoires avec Microsoft SQL Server :

SELECT TOP 1 colonne de table
ORDRE PAR NEWID()

L'extraction des données aléatoires avec IBM DB2

Colonne SELECT, ALEA() comme IDX
DE table
ORDRE PAR IDX EXTRAIRE TOUT D'ABORD 1 LIGNES SEULEMENT

L'extraction des données aléatoires avec Oracle :

Colonne SELECT FROM
(SELECT de la colonne du tableau
ORDER BY dbms_random.value)
WHERE rownum = 1
Les réponses à la ressource: « Extraction de données aléatoires de base de données »

Génie Abacus et livres de mathématiques védique - examen

Le gouvernement et les emplois privés a décidé par le biais de concours, les jeunes sont laissés avec aucun autre choix que de graver leur pétrole de minuit et améliorer leur aptitude numérique afin de rester vivant dans la Foire d'empoigne. Pour tous les « mantra » succès a été la vitesse et la précision ». Bien qu'il existe différentes méthodes pour improviser sur elle, le modèle de succès de temps mis à l'essai est le « Abacus », la technique de calculée chinois et japonais antique et le système de mathématiques védique Indiens.

Étudiants de nombreux Indiens primaire et secondaire considèrent mathématiques une question très difficile. Certains étudiants rencontrent des difficultés avec les opérations arithmétiques de base. Certains élèves sentent difficiles à manipuler de symboles et d'équilibrer les équations.En d'autres termes, le raisonnement abstrait et logique est leur obstacle.

Abacus/Vedic Moths est aujourd'hui très utile.Étant donné la formation initiale des papillons modernes dans les écoles d'aujourd'hui, étudiants seront en mesure de comprendre la logique des mathématiques Abacus et Vedic après avoir atteint la norme de l'école secondaire. Il sera d'intérêt pour tous mais plus tellement aux jeunes étudiants désireux de faire leur marque dans les examens d'entrée concurrentiel comme GRE GMAT, CAT / MBA, ITI-JEE, EAMCET, APPSC et UPSC et fini... sur

Abacus' n'est pas seulement considéré comme un outil mathématique mais aussi pour améliorer le pouvoir de concentration. Les ondes cérébrales humaines au cours de divers types d'activités de cerveau avait découvert, abacus et papillons védiques ont des effets considérables sur le cerveau humain.La méthode a déjà pris de façon magistrale dans les régions métropolitaines en Inde et à l'étranger too…but à prendre dans les zones rurales est la mission d'un génie Abacus & Vedic Moths Global School la Fondation éclairer – l'école des intellectuels.

Rompant la méthode d'enseignement traditionnel pour Abacus, la Fondation éclairer adopte védique mathématiques dans le système d'ABACUS d'accroître son champ d'application. La Fondation éclairer est une organisation éducative dynamique, très crédible, s'est engagée à fournir la qualité et de la bonne éducation pour les enseignants et les étudiants du monde entier.

« Cible et le temps sont les principales composantes de cette méthode. Nous déplacer par secondes et garder aller plus vite jusqu'à la scène lorsque intelligence devient une habitude.Dans éclairer Foundation, nous offrons une large gamme d'ABACUS et moths védique aux apprenants de différents groupes d'âge. Personnes qui aiment à enseigner et l'envie de faire une carrière épanouissante rentable en matière d'éducation. Personnes qui veulent avoir un moyen de subsistance honorable qui est mental, affectif et social s'acquitter

Les mathématiques d'ABACUS et védique mathématiques pour les étudiants de l'école secondaire une série de livres (niveaux 8 + 2) par la Fondation éclairer est un système simple et efficace pour faire de chaque enfant qui utilise plus brillantes et intelligent.Ce système de génie Abacus & Vedic Moths mesure appris par n'importe quel étudiant avec un petit effort.

Ces livres peuvent être utilisés dans les écoles, didacticiels, étudient des centres et même à la maison.Ces livres améliore les compétences d'apprentissage autant que les étudiants qui traversent ces livres montrent significatives dans l'ensemble le développement donner votre enfant d'entre les meilleurs livres « Learning mathématiques avec génie Abacus » et « Védique mathématiques pour High School Students ».C'est seulement le meilleur cadeau que vous pouvez transmettre la nouvelle génération.

Nous vous invitons à être notre partenaire dans cette innovation éducative en développement rapide en se joignant à l'éclairer Foundation Network, présenter et promouvoir Abacus védique moths système en Inde et du monde entier. Si vous êtes intéressés, veuillez communiquer avec nous pour obtenir de plus amples informations et vos précieuses suggestions et commentaires seront grandement appréciés.

 

Fondamentale de délégués

Les délégués est comme pointeur fonction c et c ++.
Programmeur utilise des délégués pour encapsuler mention la méthode dans les délégués object.Then délégués objet passe à la méthode de référence appropriée de code et d'appel et invoqué cette méthode qui n'est pas savoir au moment de la compilation.

Voici des exemples d'appel de la méthode simple en c#

à l'aide du système.

espace de noms withoutDelegate
{
public class Class1
{
public Process() void
{
Console.WriteLine ("processus commencer").
Console.WriteLine ("fin de processus") ;
}
}

public class test
{
static void main (string [] args)
{
Classe1 myClass = nouvelle Class1() ;
myClass.Process() ;
}
}
}

Cela fonctionne bien dans la plupart des situations.Parfois, cependant, nous ne voulons pas d'appeler une fonction directement - nous serait en mesure de transmettre à quelqu'un d'autre, donc ils peuvent appeler.Cela est particulièrement utile dans un système évènementielle, comme une interface utilisateur graphique, lorsque je veux un code à exécuter lorsque l'utilisateur clique sur un bouton, ou lorsque j'essaie de se connecter des informations, mais ne peut pas expliquer comment il est connecté

Dans les délégués, il y a deux types de délégués.
Délégués de SingleCast 1)
Délégués multicast 2)

Une chose intéressée sur les délégués est qu'il ne sait pas sur la classe de l'objet qu'il référence, comme tout autre objet do.All cette chose dépendent de paramètre de méthode et de type retour de méthode qui correspond à la signature des délégués.

Une signature de délégués des interprètes unique est :

déléguer l'identificateur de retour-type (paramètre)

ex : déléguer int calculer (int a, b int).

En plus exemple « int » est de type de retour de fonction, calculer est le nom de Deletate et l'int a et b de l'int sont le paramètre du délégué.

Quand nous voulons utiliser les délégués dans notre programme, tout d'abord nous devons définir la signature de méthode asigning et derniers invoquant les délégués.

3 Étapes :

-Declaration(Define Signature of Delegates)
-Instantiation(Asigning Method to delegate)
-Invoking(Invoking Delegate object so we dynamicall call method)

espace de noms délégué
{
/ / Déclaration
public delegate void MyDelegate() ;

classe TestDelegate
{
public MyFunc() void statique
{
Console.WriteLine ("j'ai été appelé par délégué...") ;
}

public main() void statique
{
/ / Instanciation
MyDelegate myDelegate = nouvelle MyDelegate(MyFunc) ;

/ / Appel
myDelegate() ;
}
}
}

Considérez l'exemple simple :

Espace de noms myNamespace
{
/ / et n'a aucun type de retour.
délégué public void myHandler(string message) ;

Et l'utilisation du délégué est comme l'appelant une fonction directement,
/ / Si nous devons ajouter une vérification pour voir si le délégué est null
/ / (c'est-à-dire ne pas pointer vers une fonction) avant d'appeler la fonction.
public void processus (gestionnaire de myHandler.)
{
Si (Handler! = null)
{
Handler("Process() commencer").
}

Si (Handler! = null)
{
Gestionnaire d'événements ("Process() fin").
}
}
}

/ / Tester l'application à utiliser le délégué défini
public class MonApplication
{
/ / Fonction statique: À qui est utilisée dans le délégué.Pour appeler la Process()
/ / fonction, nous avons besoin déclarer une fonction de journalisation : Logger() qui correspond à
/ / la signature du délégué.
static void Logger (chaîne s)
{
Console.WriteLine(s) ;
}

static void main (string [] args)
{
MyClass myClass = nouvelle MyClass() ;

/ / Crate une instance du délégué pointant vers la fonction de journalisation.
/ / Ce délégué sera ensuite passé à la fonction Process().
MyClass.myHandler myLogger = MyClass.myHandler(Logger) nouveau ;
myClass.Process(myLogger) ;
}
}
}

En multidiffusion Deletates, nous pouvons références plus d'une méthode aux délégués, mais ici une chose que nous devons nous rappeler que toute méthode ont même signature délégués.

Exemple : multidiffusion délégué :

Fonction de délégué public calculer (ByVal un As Integer, ByVal b As Integer) As Double

Public Class Delegateclass

Ajout de la fonction publique (ByVal un As Integer, ByVal b As Integer) As Double
Console.WriteLine(a + b)
Fonction de fin

Soustraire de la fonction publique (ByVal un As Integer, ByVal b As Integer) As Double
Console.WriteLine (a - b)
Fonction de fin
Classe de fin

Sub Main()
Dim myDlegateClass As New Delegateclass

Dim delAdd As New calculer (AddressOf myDlegateClass.Add)
Dim delSub As New calculer (AddressOf myDlegateClass.Subtract)
Dim delCalculate as calculer = DirectCast ([délégué] .Combine (delAdd, delSub), calculer)
delCalculate.Invoke (5, 3)
Console.ReadLine()
Fin Sub
}

Fonction à fractionner Numéro

CREATE FUNCTION [dbo].[GEN_NUMBER] (@ VAL VARCHAR(20))
RETOURNE VARCHAR(30)
COMME
COMMENCER

DÉCLARER @ LEN INT
DÉCLARER @ CH CHAR
DÉCLARER INT @ LEN1
DÉCLARER INT @ LEN2
DÉCLARER @ STINDEX INT
SET @LEN=LEN(@VAL)
SET @ LEN2 = 0
SET @ LEN1 = 0
SET @ STINDEX = 0
ALORS QUE (@ LEN > 0 ET @ LEN>=@LEN1)
COMMENCER
DÉFINISSEZ @ LEN1=@LEN1+1
SET @CH=SUBSTRING(@VAL,@LEN1-1,@LEN1)
SI PATINDEX('%[0-9]%',@CH) > 0
COMMENCER
SI @ LEN2<>
COMMENCER
DÉFINISSEZ @ LEN2=@LEN1
SI (@ STINDEX = 0)
DÉFINISSEZ @ STINDEX=@LEN2
FIN
FIN

FIN
SI (@ LEN2 > 0)
COMMENCER
SET @ LEN2 = CONVERT(INT,SUBSTRING(@VAL,@LEN2-1,LEN(@VAL)))
DÉFINISSEZ @ LEN2=@LEN2+1
FIN
AUTRE
SET @ LEN2 = 0
RETOUR SUBSTRING(@VAL,0, @STINDEX-1) + CONVERT (VARCHAR(20),@LEN2)

FIN

Espace de noms en c#

Un espace de noms est un domaine dans lequel type nom doit être unique. Types sont généralement organisées dans les espaces de noms hiérarchique — tant pour éviter les conflits de noms et faire des noms de type plus facile à trouver. Par exemple, le type RSA, qui gère le cryptage de la clé publique, est défini dans l'espace de noms suivant :

System.Security.Cryptography

Un espace de noms fait partie intégrante du nom d'un type.Le code suivant appelle la méthode Create RSA :

Rsa System.Security.Cryptography.RSA = System.Security.Cryptography.RSA.Create () ;

Le mot-clé de l'espace de noms définit un type au sein d'un espace de noms.Par exemple :

espace de noms Outer.Middle.Inner
{
classe Classe1 {}
classe Classe2 {}
}

Les points en l'espace de noms indiquent une hiérarchie des espaces de noms imbriqués.Ce qui suit est sémantiquement identique à l'exemple précédent :

espace de noms des
{
espace de noms moyen
{
espace de noms intérieure
{
classe Classe1 {}
classe Classe2 {}
}
}
}

Using directive importe un espace de noms.Il s'agit d'un moyen pratique pour faire référence aux types sans leurs noms qualifiés complets.Par exemple :
à l'aide de Outer.Middle.Inner.
classe test / / test est dans l'espace de noms global
{
static void main)
{
Classe1 c ;/ / Nom qualifié complet est inutile
}
}

Une utilisation directive peut être imbriqué dans un espace de noms lui-même afin de limiter le champ d'application de la directive

Tous les noms présents dans les espaces de noms externe sont implicitement importées dans les espaces de noms interne.Dans cet exemple, les noms de moyen et Classe1 sont implicitement importées dans intérieure :

espace de noms des
{
espace de noms moyen
{
classe Classe1 {}

espace de noms intérieure
{
classe Classe2 : Class1 {}
}
}
}

Si vous voulez faire référence à un type dans une branche différente de votre hiérarchie de l'espace de noms, vous pouvez utiliser un nom partiellement qualifié.Dans l'exemple suivant, nous basons SalesReport sur Common.ReportBase :

espace de noms MyTradingCompany
{
espace de noms communs
{
classe ReportBase {}
}
espace de noms ManagementReporting
{
la classe SalesReport : Common.ReportBase {}
}
}

Si le même nom de type apparaît dans une iAnywhere.Data.UltraLite intérieure et extérieure, le nom interne gagne.Pour faire référence au type externe, vous devez utiliser le nom qualifié complet.

À l'occasion, un nom de type qualifié complet peut entrer en conflit avec un nom interne.Vous pouvez forcer c# à utiliser le nom de type qualifié complet en préfixant il avec global:: comme suit :

Global:: System.Text.StringBuilder sb.

Dessiner une ligne sur Windows Form

Contrôles Winforms extraits de code de ressources » » »

Ce code montre comment vous pouvez dessiner une ligne dans un Windows Form simple

Tracer des lignes simples sur un formulaire Windows n'est pas facile car il n'y a aucun contrôle en ligne.Vous pouvez encore faire une ligne en utilisant un contrôle Panel et en définissant sa largeur ou une hauteur de quelques pixels.Mais si vous souhaitez une véritable ligne, le secret est dans la compréhension de l'ensemble correcte des méthodes de la bibliothèque dont vous avez besoin.

Pour dessiner une ligne de code, que vous devez utiliser GDI + (c.-à-d. la bibliothèque .NET graphique)

En Visual Basic :

Private Sub btnOk_Paint (ByVal sender As Object, ByVal e As System.Windows.Forms.PaintEventArgs) Handles MyBase.Paint
Dim g As Graphics = e.Graphics
Dim penLine as PEN = New Pen(Color.CornflowerBlue, 12)
g.DrawLine (penLine, 15, 0, 15, me.Height)
penLine.Dispose()
Fin Sub

En c# :

private void btnOk_Paint (objet sender,System.Windows.Forms.PaintEventArgs e)
{
Graphique g = e.Graphics ;
PEN penLine = nouveau stylet (Color.CornflowerBlue, 12) ;
g.DrawLine (penLine, 15, 0, 15, this.Height).
penLine.Dispose() ;
}
Les réponses à la ressource: « Dessine en ligne sur Windows Form »

Membres en ligne
Manoranjan Sahoo
Meghaa Joshiee
Plus...

Démarrer Windows XP plus rapide

Maintenant, voici quelques conseils pour démarrer plus rapidement votre xp.Alors commençons:-

1. Tout d'abord ouvrir notepad.exe, tapez « del c:\windows\prefetch\ntosboot-*.* q » (sans les guillemets) & enregistrez sous « ntosboot.bat » dans la c:\.
2. Du menu Démarrer et sélectionnez « Run... » & tapez « gpedit.msc ».
3. Double cliquez sur "Paramètres Windows" sous « Configuration de l'ordinateur » et double cliquez de nouveau sur « Arrêt » dans la fenêtre de droite.
4. Maintenant dans la nouvelle fenêtre juste cliquez sur "ajouter", "Explorer" et recherchez votre fichier « ntosboot.bat » & cliquez sur « Ouvrir ».
5. Après cela, cliquez sur « OK », « Appliquer » & cliquez sur « OK », une fois de plus à la sortie.
6. Dans le menu Démarrer, sélectionnez « Exécuter... » & « devmgmt.msc » de type.
7. Double cliquez sur « Contrôleurs IDE ATA/ATAPI ».
8. Droite cliquez sur « Les IDE Channel » et sélectionnez « Propriétés ».
9. Sélectionnez l'onglet « Paramètres avancés », puis sur le périphérique ou 1 qui n'a pas « type de dispositif » grisé, sélectionnez 'none' au lieu de « autodétection » & cliquez sur « OK ».
10. Ce est cliquez tout droit sur « Canal IDE secondaire », sélectionnez « Propriétés » et répétez l'étape 9.
11. Redémarrez votre ordinateur.

Ne vous inquiétez pas DOOD, il sera certainement fonctionne.
Prenez juste!!!

Contrôle AdRotator avec SQLServer

Description de types de données de nom de colonne
-------------------------------------------------------------------------------------------------------------
ID int clé primaire.Cette colonne peut avoir n'importe quel nom.

ImageUrl nvarchar(length) l'URL relative ou absolue de l'image
affichage de la publicité.

NavigateUrl nvarchar(length) l'URL cible pour la publicité.Si vous ne fournissez pas
une valeur, la publicité n'est pas un lien hypertexte.

AlternateText nvarchar(length) le texte affiché si l'image est introuvable.
Dans certains navigateurs, le texte s'affiche comme une info-bulle.
Texte de remplacement est également utilisé pour l'accessibilité afin que
les utilisateurs qui ne peuvent pas voir le graphique peuvent entendre sa description
lire à voix haute.

Mot clé nvarchar(length) une catégorie pour la publicité sur lequel la page peut filtrer.

Impressions int(4) un certain nombre qui indique la probabilité de façon souvent
la publicité est affichée.Plus le nombre, la plus
souvent l'annonce sera affichée.Le total de tous les
valeurs d'impressions dans le fichier XML ne peuvent pas dépasser
2,048,000,000 - 1.

Int(4) la largeur de l'image en pixels de largeur.

Int(4) la hauteur de l'image en pixels de hauteur.
------------------------------------------------------------------------------------------------------------

Comment valider à l'aide de Regular Expression

ControlToValidate = « TextBox1 » ErrorMessage = « entrez le format d'heure valide »
SetFocusOnError = « True »
ValidationExpression = "^ [\d] {2} [:] [\d] {2} [:] [\d]$ {2}"
ValidationGroup = « a » >

Comment installer / désinstaller Silverlight

Comment faire pour installer Silverlight :

• Allez à http://www.silverlight.net/

• Cliquez ici pour installer le bouton Télécharger Silverlight.exe

• Double cliquez Silverlight.exe

• Ce sera ouvert « Avertissement de sécurité – de Open File » comme assistant de course de Silverlight

• Cliquez sur exécuter Button

• Ce sera ouvert « Assistant Installation de Silverlight »

• Cliquez sur Installer maintenant bouton

• Après, vous pouvez voir message « Installation réussie » pour Silverlight

• Enfin, cliquez sur Fermer Button

Comment faire pour désinstaller des Silverlight :

• Start menu-> Paramètres-> Panneau de configuration cliquez

• Double cliquez sur Ajouter ou supprimer des programmes

• Ce sera ouvert « Ajouter ou supprimer programmes Assistant »

• Découvrez installé Microsoft Silverlight.Puis cliquez sur Supprimer le bouton

• Après, vous pouvez voir message « are vous assurer que vous souhaitez supprimer Microsoft Silverlight de votre ordinateur? »

• Cliquez sur Oui Button

Pour plus de détails, visitez le http://santha-learntechnicalknowledge.blogspot.com

Besoin de loisirs dans l'industrie informatique

Besoin de loisirs dans l'industrie informatique

Loisirs actualise notre esprit, corps et âme. Ainsi, il est vraiment nécessaire.Mais, c'est comme « Vitamine ». Vitamine est nécessaire pour notre corps et notre corps prendre que beaucoup vitamine ce que le corps exactement besoin et si nous prenons un montant excédentaire de vitamine comparativement à la nécessité de notre corps, puis le corps ne tient pas du tout la vitamine montant supplémentaire, il faut seulement à la quantité, il exige.

Dans le cas de loisirs, non seulement notre corps mais aussi notre esprit et l'âme prennent leur quantité nécessaire d'énergie pour obtenir actualisé de la récréation.

Si vous ne faites pas de loisirs mais prenez uniquement de repos puis également votre esprit, corps et âme obtient actualisé. Mais c'est une procédure très lente.Loisirs pendant une heure peut être égal au reste de cinq jours.

Et compte tenu de l'industrie informatique ?Oui, il faut beaucoup, et vous pouvez aussi dire que c'est obligatoire.Parce que nous fonctionnent dans l'industrie informatique sous forte pression du délai spécialement lorsqu'il existe un projet live, nous travaillons avec.Nous allons faire notre bureau tous les jours, nos y travaillent et arrivé à la maison.Puis le lendemain, la même routine.Notre esprit, le corps et âme deviennent fatigués et spécialement notre esprit deviennent très fatigué et s'ennuie trop.Donc si vous ferez des loisirs pour seulement 1 heure puis vous obtiendrez plus productifs résultats dans votre IT liés travail.

Base respecte des génériques en c#

Translate Request has too much data
Parameter name: request

In C# there is two types of mechanism for writing code that is reusable across different type.
1)Inheritance
2)Generic.

Inheritance express reusability across base type,while generic express reusability with a template that contains placeholder.

Mainly Generics used for type safety and reducing casting and boxing.

Now first glance on Generic Types.

A generic type declares generic parameters—placeholder types to be filled in by the consumer of the generic type, who will supply the generic arguments. Here is a generic type Stack, designed to stack instances of type T. Stack declares a single generic parameter T:

public class Stack
{
int position;
T[] data = new T[100];
public void Push (T obj) { data[position++] = obj; }
public T Pop() { return data[--position]; }
}

We can use Stack as follows:

Stack stack = new Stack ();
stack. Push(5);
stack. Push(10);
int x = stack.Pop(); // x is 10
int y = stack.Pop(); // y is 5

Stack fills in the generic parameter T with the generic argument int, implicitly creating a type on the fly (the synthesis occurs at runtime). Stack effectively has the following definition (substitutions appear in bold, with the class name hashed out to avoid confusion):

public class ###
{
int position;
int[] data;
public void Push (int obj) { data[position++] = obj; }
public int Pop() { return data[--position];}
}

Technically, we say that Stack is an open type, whereas Stack is a closed type. You can only instantiate a closed type, because all the placeholder types must be filled in.

Why generics exist?

Different types of generic code that is reusable for writing exist. Let's say we need a stack of integers, but we did not have normal type. All the necessary elements for a solution (eg, IntStack, StringStack, etc.) Clearly, this type of code duplication would cause quite a different version of the class will hardcode. Another solution is to write a stack object by using the element type as would be generalized:

public class ObjectStack
{
int position;
object[] data = new object[10];
public void Push (object obj){data[position++] = obj;}
public object Pop() { return data[--position];}
}

An ObjectStack, however, wouldn't work as well as a hardcoded IntStack for specifically stacking integers. Specifically, an ObjectStack would require boxing and downcasting that could not be checked at compile time:

// Suppose we just want to store integers here:
ObjectStack stack = new ObjectStack();

stack.Push ("s"); // Wrong type, but no error!
int i = (int)stack.Pop(); // Downcast - runtime error

What we need is both a general implementation of a stack that works for all element types, and a way to easily specialize that stack to a specific element type for increased type safety and reduced casting and boxing. Generics give us precisely this, by allowing us to parameterize the element type. Stack has the benefits of both ObjectStack and IntStack. Like ObjectStack, Stack is written once to work generally across all types. Like IntStack, Stack is specialized for a particular type—the beauty is that this type is T, which we substitute on the fly.

A generic method declares generic parameters within the signature of a method.

With generic methods, many fundamental algorithms can be implemented in only a general-purpose way. Here is a generic method that swaps two values of any type:

static void Swap (ref T a, ref T b)
{
T temp = a; a = b; b = temp;
}

Swap can be used as follows:

int x = 5, y = 10;
Swap (ref x, ref y);

Generally, there is no need to supply type parameters to a generic method, because the compiler can implicitly infer the type. If there is ambiguity, generic methods can be called with the type parameters as follows:

Swap (ref x, ref y);

Within a generic type, a method is not classed as generic unless it introduces generic parameters (with the angle bracket syntax). The Pop method in our generic stack merely uses the type's existing generic parameter, T, and is not classed as a generic method.

Methods and types are the only constructs that can introduce generic parameters. Properties, indexers, events, fields, methods, operators, and so on cannot declare generic parameters, although they can partake in any generic parameters already declared by their enclosing type. In our generic stack example, for instance, we could write an indexer that returns a generic item:

public T this [int index] { get {return data [index];} }

Generic parameters can be introduced in the declaration of classes, structs, interfaces, delegates (see the upcoming "Delegates" section), and methods. Other constructs, such as properties, cannot introduce a generic parameter, but can use a generic parameter. For example, the property Value uses T:

public struct Nullable
{
public T Value {get;}
}

A generic type or method can have multiple parameters. For example:

class Dictionary {...}

To instantiate:

Dictionary myDic = new Dictionary();
var myDic = new Dictionary();

Generic type names and method names can be overloaded as long as the number of generic parameters is different. For example, the following two type names do not conflict:

class A {}
class A {}

typeof and Generics

The typeof operator requires specifying the number of parameters when asking for the type of an open type, as follows:

class A {}
class A {}
...

Type a1 = typeof(A<>);
Type a2 = typeof(A<,>);

Here is an example of asking for the type of a closed type:

Type a3 = typeof(A);

The default keyword can be used to get the default value given a generic type argument. The default value for a reference type is null, and the default value for a value type is the result of bitwise-zeroing the value type's fields:

static void Zap (T[] array)
{
for (int i = 0; i < array.Length; i++)
array[i] = default(T);
}

By default, a generic parameter can be substituted with any type whatsoever. Constraints can be applied to a generic parameter to require more specific type arguments. These are the possible constraints:

where T : base-class // Base class constraint
where T : interface // Interface constraint
where T: class // Class constraint
where T : struct // Struct constraint
where T : new() // Parameterless constructor
// constraint
where U : T // Naked type constraint

In the following example, GenericClass requires T to derive from SomeClass and implement Interface1:

class SomeClass {}
interface Interface1 {}

class GenericClass where T : SomeClass, Interface1 {}

Constraints can be applied wherever generic parameters are defined, in both methods and type definitions.

A base class constaint or interface constraint specifies that the type parameter must subclass or implement a particular class or interface. This allows instances of that type to be implicitly cast to that class or interface. For example, suppose we want to write a generic Max method that returns the maximum of two values. We can take advantage of the generic interface defined in the System namespace IComparable:

public interface IComparable
{
int CompareTo (T other);
}

CompareTo returns a positive number if other is greater than this. Using this interface as a constraint, we can write a Max method as follows (to avoid distraction, null checking is omitted):

static T Max (T a, T b) where T : IComparable
{
return a.CompareTo (b) > 0 ? a : b;
}

The Max method can accept arguments of any type implementing IComparable (which includes most built-in types such as int and string):

int z = Max (5, 10); // 10
string last = Max ("ant", "zoo"); // zoo

The class constraint and struct constraint simply specify that T must be a class or a struct. A great example of the struct constraint is the System.Nullable struct (we will discuss this class in depth, later, in the "Nullable Types" section):

struct Nullable where T : struct {...}

The parameterless constructor constraint requires T to have a public parameterless constructor. If this constraint is defined, you can call new() on T:

static void Initialize (T[] array) where T : new()
{
for (int i = 0; i < array.Length; i++)
array[i] = new T();
}

The naked type constraint requires one generic parameter to derive from another generic parameter. In this example, the method FilteredStack returns another Stack, containing only the subset of elements where the generic parameter T is of the generic parameter U:

class Stack
{
Stack FilteredStack() where U : T {...}
}

Generic types are not covariant. This means that even if B can be cast to A, T cannot be cast to T. For example, suppose Animal and Bear are defined as follows:

class Animal {}
class Bear : Animal {}

The following is illegal:

Stack bears = new Stack ();

// compile-time error
Stack animals = bears;

Lack of covariance can hinder reusability. Suppose, for instance, we wanted to write a method to Wash a stack of animals:

public class ZooCleaner
{
public static void Wash (Stack animals) {...}
}

Calling Wash with a stack of bears would generate a compile-time error. The workaround is to redefine the Wash method with a constraint:

public class ZooCleaner
{
public static void Wash (Stack animals)
where T : Animal {}
}

We can now call Wash as follows:

Stack bears = new Stack();
ZooCleaner.Wash (bears);

A generic class can be subclassed just like a nongeneric class. The subclass can leave the base class's generic parameters open, as in the following example:
class Stack {...}
class SpecialStack : Stack {...}

Or the subclass can close the generic type parameters with a concrete type:

class IntStack : Stack { ... }

A subclass can also introduce fresh generic arguments:

class Single { ... }
class Double : Single { ... }

A type can name itself as the concrete type when closing a generic argument:
public interface IEquatable { bool Equals (T obj); }

public class Balloon : IEquatable
{
string color;
int cc;

public bool Equals (Balloon b)
{
if (b == null) return false;
return b.color == color && b.cc == cc;
}
}

Static data is unique for each closed type:

class Bob { public static int Count; }

class Test
{
static void Main()
{
Console.WriteLine (++Bob.Count); // 1
Console.WriteLine (++Bob.Count); // 2
Console.WriteLine (++Bob.Count); // 1
Console.WriteLine (++Bob