Comment "importer" une classe statique en C #?

Ce que Jon Skeet n'est pas vous dire, c'est que vous peut globale des membres statiques en c#. Votre classe utilitaire peut en effet devenir une réalité en c#.

Malheureusement, Microsoft a déterminé que le processus de construction de ces membres comme au-dessus de la simple développement "normal", et exige que vous forge de raw langage intermédiaire. Un puissant motif est au-dessus de communes de la syntaxe et de l'amicale des icônes).

Ici est la condition de la séquence de caractères utf-8 (il garde soigneusement):

.assembly globalmethods {}

.method static public void MyUtilMethod() il managed 
{
  ldstr "Behold, a global method!"
  call void [mscorlib]System.Console::WriteLine(class System.String) 
  ret
}

(Vous pouvez compiler cet exemple en invoquant ilasm.exe à partir du SDK invite de commande, se souvenant de l'utilisation de la dll switch)

---

ilasm.exe sortie:

Microsoft (R) .NET Framework IL Assembler. Version 2.0.50727.4016
Copyright (c) Microsoft Corporation. Tous droits réservés.
L'assemblage 'globalmethods.msil " pour DLL --> 'globalmethods.dll'
Le fichier Source est ANSI

mondiale.msil(7) : avertissement-Référence non déclarées extern assemblée 'mscorlib'.
La tentative d'auto-détection

Assemblé mondiale de la méthode MyUtilMethod

La création de fichier PE

Émettant des classes:

Émettant des champs et des méthodes:
Les Méthodes Globales: 1;

Émettant des événements et des propriétés:
Mondial
L'écriture du fichier PE
L'opération s'est déroulée avec succès

---

Une fois que vous avez compilé votre nouvellement créé de l'assemblée ("globalmethods.dll" par exemple), c'est juste une question de l'ajout d'une référence dans Visual Studio. Lorsque ce est terminé, vous feriez mieux d'être assis, car il sera temps d'écrire un peu de code réel:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

namespace TestGlobalMethod
{
    class Program
    {
        static void Main(string[] args)
        {

            "MyUtilMethod".Call();

            Console.ReadKey();

        }

    }

    ///<summary>
    ///Reduces the amount of code for global call
    ///</summary>
    public static class GlobalExtensionMethods 
    {
        public static void Call(this string GlobalMethodName)
        {
            Assembly.Load("globalmethods")
                .GetLoadedModules()[0].GetMethod(GlobalMethodName)
                    .Invoke(null,null);

        }

    }


}

Oui, vous avez appelé une méthode Globale en c#.

*S'il vous plaît ne pas l'utiliser, c'est uniquement à titre d'exemple 🙂 Aussi, vous pourriez probablement écrire vos méthodes globales dans une autre langue qui les prennent en charge, tels que VB.NET.

Au minimum, vous devez indiquer au moins le nom de la classe. Tous les à l'aide de la directive n'est de vous permettre de laisser de côté l'espace de noms. Vous pouvez également utiliser l'aide de la directive pour spécifier un alias à la Place de l'ensemble de la namespace.class nom, mais alors vous devez utiliser l'alias...

using MyClassName = Namespace.MySubNS.OtherNameSpace.OriginalClassname;

MyClassName X = new MyClassName(); 

Dans ce fil il y a quelques interrogations et argumenation de ne pas utiliser les méthodes globales, mais je voudrais ajouter qu'il ya un autre genre de scénario lors de la statique des importations sont souhaitables, par exemple lorsque vous souhaitez apporter à certaines constantes dans l'étendue.
Par exemple, si je veux construire des instructions SQL, je préfère ne pas utiliser dupliqué les littéraux de chaîne, comme dans cet exemple de code (à l'aide de dynasql):

            DBQuery.Select()
            .Field("CustomerID")
            .Count("OrderID")
            .From("Orders")
            .GroupBy("CustomerID")
            .OrderBy("CustomerID")
            .WhereField("OrderDate", Compare.GreaterThan, DBConst.DateTime(ordersAfter))

Je préfère le faire:

            public class OrderTable {
                public const string Orders = "Orders";
                public const string CustomerID = "CustomerID";
                public const string OrderID = "OrderID";
                public const string OrderDate = "OrderDate";
            }
            ...
            DBQuery.Select()
            .Field(OrderTable.CustomerID)
            .Count(OrderTable.OrderID)
            .From(OrderTable.Orders)
            .GroupBy(OrderTable.CustomerID)
            .OrderBy(OrderTable.CustomerID)
            .WhereField(OrderTable.OrderDate, Compare.GreaterThan, DBConst.DateTime(ordersAfter))

Si je serais à l'aide de la suggestion par le Loadmaster (16 Oct à 16:49) alors je pourrais faire ceci:

            using O = TestingDynasql.OrderTable;
          ...
            DBQuery.Select()
            .Field(O.CustomerID)
            .Count(O.OrderID)
            .From(O.Orders)
            .GroupBy(O.CustomerID)
            .OrderBy(O.CustomerID)
            .WhereField(O.OrderDate, Compare.GreaterThan, DBConst.DateTime(ordersAfter))             

Cependant, je préfère apporter la constante dans le champ d'application répétée mais nécessaire nom et dot qualifer à tous (que vous pouvez faire avec Java statique des importations), c'est à dire le faire:

            DBQuery.Select()
            .Field(CustomerID)
            .Count(OrderID)
            .From(Orders)
            .GroupBy(CustomerID)
            .OrderBy(CustomerID)
            .WhereField(OrderDate, Compare.GreaterThan, DBConst.DateTime(ordersAfter))             

Mais il n'est pas possible d'utiliser ce type de syntaxe avec C# ?

Par la manière, personne ne sait de mieux .NET-library pour la création de SQL que dynasql, ce qui ne semble pas être conçu pour être indépendant de l'exécution de SQL (comme le problème décrit ici: http://dynasql.codeplex.com/Thread/View.aspx?ThreadId=81988)
?

/Sven

Je ne suis pas sûr de ce que vous essayez d'accomplir en omettant la Utils du préfixe d'appels de méthode. Mais si c'est juste pour économiser de l'espace ou de rendre le code un peu plus facile à lire, vous pourriez alias l'importation d'un nom plus court:

using U = Utils;

Avec C# 6, vous pouvez maintenant utiliser des importations (voir msdn) Par exemple,

using static Utils;