jak zadeklarować globalną funkcję lub metodę za pomocą C#?

Question

Czy ktoś może mi powiedzieć, jak zadeklarować funkcję globalną w języku C#, podobne do tego, co robi Module w VB.net? Muszę wywołać funkcję, która może być wywoływana w moim formularzu1, formularzu2 i formularzu3.

---

mam ten kod:

using System.Data.OleDb; 

namespace XYZ 
{ 
    public static class Module 
    { 
     public static void dbConnection() 
     { 
      OleDbConnection con = new OleDbConnection(); 
      con.ConnectionString = "provider= microsoft.jet.oledb.4.0;data source=..\\dbCooperative.mdb"; 
      con.Open(); 
     } 
    } 
} 

i Form1:

using System.Data.OleDb; 
using XYZ; 

namespace XYZ 
{ 
    public partial class frmReports : Form 
    { 
     public frm1() 
     { 
      InitializeComponent(); 
     } 

     private void frm1_Load(object sender, EventArgs e) 
     { 
      Module.dbConnection(); 
      OleDbCommand cm = new OleDbCommand("SELECT * FROM table", con); 
     } 
    } 
} 

ale wystąpił błąd: "Nazwa 'con' nie istnieje w bieżącym kontekście".

Answer 1

Można utworzyć klasę statyczną.

namespace MyNamespace 
{ 
    public static class MyGlobalClass 
    { 
     public static void MyMethod() { ... } 
    } 
} 

można byłoby następnie dodać przestrzeń nazw w sekcji using swojej klasie wywołującego do niego dostęp. Tak:

using MyNamespace; 

public class CallingClass 
{ 
    public void CallingMethod() 
    { 
     MyGlobalClass.MyMethod(); 
    } 
} 

Answer 2

Można utworzyć klasę statyczną (nawet ująć go w jego własnej przestrzeni nazw, tak aby nie zanieczyścić główną nazw projektu), a następnie zadzwonić z dowolnego miejsca:

namespace SomeNamespace 
{ 
    public static class SomeClass 
    { 
     public static string SomeMethod() 
     { 
      ... 
     } 
    } 
} 

Następnie w kodzie, można nazwać to, używając:

string x = SomeNamespace.SomeClass.SomeMethod(); 

Lub można skonfigurować using w górnej części kodu i po prostu odwoływać bez nazw:

using SomeNamespace; 
... 
string x = SomeClass.SomeMethod(); 

Answer 3

Jeśli używasz C# 6.0 lub nowszego, możesz użyć using static.

Na przykład

using static ConsoleApplication.Developer; 

namespace ConsoleApplication 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      // Global static function, static shorthand really 
      DeveloperIsBorn(firstName: "Foo", lastname: "Bar") 
       .MakesAwesomeApp() 
       .Retires(); 
     } 
    } 
} 

namespace ConsoleApplication 
{ 
    class Developer 
    { 
     public static Developer DeveloperIsBorn(string firstName, string lastname) 
     { 
      return new Developer(); 
     } 

     public Developer MakesAwesomeApp() 
     { 
      return this; 
     } 
     public Developer InsertsRecordsIntoDatabaseForLiving() 
     { 
      return this; 
     } 

     public void Retires() 
     { 
      // Not really 
     }   
    } 
} 

Jeszcze jeden przykład:

using static System.Console; 

namespace ConsoleApplication7 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      WriteLine("test"); 
     } 
    } 
} 

Answer 4

@kol ma rację, nie ma globalne funkcje w C#. Spójrz na ten post MSDN post. Chciałbym używać warstw (I zmieniono nazwę klasy „Module” do „TransactionsModule”) i będzie to wyglądać tak:

using System; 
using System.Collections.Generic; 
using System.Data.OleDb; 

namespace XYZ 
{ 
    public class TransactionsModule 
    { 
     public List<Person> GetPersons(string query, string connectionString) 
     { 
      List<Person> dbItems = new List<Person>(); 

      OleDbConnection conn = new OleDbConnection(connectionString); 

      try 
      { 
       conn.Open(); 
       var cmd = new OleDbCommand(query, conn); 
       cmd.CommandText = query; 

       using (OleDbDataReader reader = cmd.ExecuteReader()) 
       { 
        Person objPerson = new Person(); 

        //These are the columns returned 
        objPerson.Name = Convert.ToString(myReader["Name"]); 
        objPerson.Age = Convert.ToInt32(myReader["Age"]); 

        dbItems.Add(objPerson); 
       } 
      } 
      catch(OleDbException ex) 
      { 
       throw ex; 
      } 
      finally 
      { 
       conn.Close(); 
      } 
      return dbItems;   
     } 


    } 

    //This class should be in another Layer, but I placed it here since It's a quick Example 
    public class Person 
    { 
     public string Name { get; set; } 
     public int Age { get; set; } 
    } 
} 

Cała logika została oderwana od klasy TransactionsModule, potem trzeba tylko wywołać metodę: GetPersons. Spójrz:

using System; 
using System.Collections.Generic; 
using XYZ.TransactionsModule; 

namespace XYZ 
{ 
    public partial class frmReports : Form 
    {  
     public frm1() 
     { 
      InitializeComponent(); 
      protected TransactionsModule moduleTran; 
     } 

     private void frm1_Load(object sender, EventArgs e) 
     { 
      //We initialize the Data Access Layer class 
      moduleTran = new TransactionsModule(); 

      //This ConnectionString should be in your app.config 
      string conString = "provider= microsoft.jet.oledb.4.0;data source=..\\dbCooperative.mdb"; 
      string sqlQuery = "SELECT * FROM table"; 

      List<Person> ItStaff = moduleTran.GetPersons(sqlQuery, conString); 
     } 
    } 
}