Autor Beitrag
StarGazer
Hält's aus hier
Beiträge: 3



BeitragVerfasst: So 15.11.09 19:40 
Hallo,

ich hab zwar schon einige Programmierkentiniese, bin aber in C-Shaprt noch ziemlisch frisch.

Ich möchte im MainFile möglist wenig deklarieren, und so viel wie möglich nach außen verlagern.
ZB InlucdeFiles von komplexere Functionen und einigen globalen Variablen, die ich dann je nach Project einlade.
Auch möchte ich nicht im MainFile ingendwelche Klassen in Variablen deklarieren, sondern dies auch in externen Files machen. Diese sollten aber dennoch von überall ansprechbar sein.
Also quasie im MainFile nichts deklarieren, sondern bloß einladen. Ich hab schon einiges versucht, aber kriege es nicht hin.

Wie ich gesehen habe gibt es da auch sowas wie "using System;" ect. Kann man soetwas auch für eigene erstellte CodeFiles machen ?

im Grunde möchte einfach nur das
ausblenden C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
//EXTERNES FILE oder Klasse

SpriteBatch sbatch; //KlassenVariable erstellen, die ich aus dem Main raushalte

public DrawImage (Texture2D texture, float x, float y)
{
  sbatch.Draw(texture, new Vector2 (x, y), new [b]Color[/b](2552552550));  //KlassenVariable hier aufrufen
}


//im MAIN

DrawImage (texture, x, y)


ich hoffe es kann mir jemand helfen.
Christian S.
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 20451
Erhaltene Danke: 2264

Win 10
C# (VS 2019)
BeitragVerfasst: So 15.11.09 20:14 
Hallo und :welcome:!

Ich glaube, hier ist es wichtig, erst einmal die verschiedenen "Einheiten" eines .NET-Assemblies zu erklären.

Ein .NET-Assembly ist im Prinzip das, was Du bekommst, wenn Du ein einzelnes Projekt kompilierst: Eine Exe- oder eine Dll-Datei. Ein solches Assembly enthält Klassen, welche in Namespaces organisiert sind. Die einzelnen Sourcecode-Dateien, die im Projekt stecken, sind für die Ordnung nach dem Kompilieren unerheblich.

Namespaces sind die einzige Ordnung für Deine Klassen. Dabei kann ein Namespace sich über mehrere Assemblies erstrecken, kann also durch das Einbinden weiterer Assemblies erweitert werden.

Dein Projekt, welches in ein Assembly kompiliert wird, enthält nun verschiedene Quellcode-Dateien. Diese beginnen alle damit, dass angegeben wird, Klassen welchen Namespaces sie enthalten. Und das ist das einzige, was Du brauchst, um den Inhalt aus anderen Dateien im selben Projekt zu benutzen! Du bindest niemals Dateien ein, sondern immer nur Namespaces, das machst Du mit "using".

Wenn Du also eine Datei "a.cs" hast und eine Datei "b.cs", welche Klassen desselben Namespaces enthalten, musst Du gar nichts tun, um die Klassen der einen in der anderen Datei zu benutzen. Hast Du eine "c.cs", welche Klassen eines anderen Namespaces enthält, bindest Du in "a.cs" oder "b.cs" diesen Namespace und nicht die Datei ein.

Nun werde ich nicht ganz aus Deinem Quelltext schlau, was Du eigentlich auslagern möchtest. In C# schreibt man ja Klassen, die kann ich bei Dir aber nicht wirklich erkennen. Möchtest eine Klasse über mehrere Dateien verteilen, kannst Du das mittels "partial classes" tun, die Doku dürfte da ein paar gute Beispiele bereit halten, wirklich schwer ist das nicht.

Interessant wäre da wohl, warum Du eigentlich irgendwas auslagern willst.

Grüße
Christian

_________________
Zwei Worte werden Dir im Leben viele Türen öffnen - "ziehen" und "drücken".
StarGazer Threadstarter
Hält's aus hier
Beiträge: 3



BeitragVerfasst: So 15.11.09 21:48 
Danke dir für deine ausführliche Antwort, und fürs herzliche begrüssen ^^.
Ich hab auch so einigermassen verstanden was du meist ^^ Also wenn, dann müste man das mit " using " lösen. Nur noch eine erklärung finden wie :), oder wo man die Files ablegen muß um sie herreinladen zu können.

Der grund warum ich aus dem Main vieles auslagern möchte, ist, damit es im Main schön übersichtlich sauber bleibt.
Ich habe einige Tutrial zu CSharp durchgekaut, und wie sie es dort alle lösten, gibt mir das grauen. Bei ihnen wird alles direkt im Main deklariert.
ZB hier aus einem Tutorial
ausblenden volle Höhe C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
namespace Beginner_Guide
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        
        GraphicsDevice device;
        int screenWidth;
        int screenHeight;

        SpriteFont font;

        Texture2D backgroundTexture;
        Texture2D foregroundTexture;
        Texture2D carriageTexture;
        Texture2D cannonTexture;
        
        PlayerData[] playerDim;
        int numberOfPlayers = 4;
        float playerScaling;

        int currentPlayer = 0;

        Texture2D rocketTexture;
        Texture2D smokeTexture;
        Texture2D explosionTexture;
        bool rocketFlying = false;
        Vector2 rocketPosition;
        Vector2 rocketDirection;
        float rocketAngle;
        float rocketScaling = 0.1f;

        List<Vector2> smokeList = new List<Vector2>();
        List<ParticleData> particleList = new List<ParticleData>();
        Random randomizer = new Random();

        int[] terrainContour;
        Texture2D groundTexture;
        
        Color[,] rocketColorArray;
        Color[,] foregroundColorArray;
        Color[,] carriageColorArray;
        Color[,] cannonColorArray;

        Color[,] explosionColorArray;   // Loch in den Boden erstellen

        public Game1()
        {

er legt allerei Variablen dirket im Main ab, und das nur bei so einem Minispielchen. Wie würde da es erst in einem größerem Projekt aussehen. Zwar erstellte er auch Klassen, es sind dann aber nur einzene Strukturen, die dann als KlassenVariable doch wieder in Main erzeutgt werden. Ich finde das ist keine schöne Lösung.

Ich möchte am liebsten zb für Enemys, eine eigene Klasse oder Externes File erstellen. Darin alle benötigen dinge coden, die jedoch auch auf andere externe Klassen zugreifen können müssen, und dort auch die Globalen KlassenVariablen erzeugen, und im Main mache dann einfach nur noch UpdateEnemy, und fetig ist.

Zb möchte ich eine art Wrapper schreiben, den ich je nach Engine anpasse. Und egal welchen EngineWrapper ich dann einlade, der rest des Coden bleit unberührt, da die functionsNamen gleich bleiben.

Ich konnte daß bisher so lösen, doch ich finde daß irgendwie doppeltgelmoppelt, Wrapper.Warp..... unsing zuviel.
ausblenden volle Höhe C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
class Wrapper {

  public static Wrapper Wrap;

  public void DrawImage (Texture2D texture, float x, float y)
  {
    spriteBatch.Draw(texture, new Vector2(x, y), new Color(2552552550));
  }

}



namespace MyProject
{
  public class Game1 : Microsoft.Xna.Framework.Game
  {


    protected override void Draw(GameTime gameTime)
    {

      // und hier im Main oder in anderen Classen dann einfach immer die gleich Function aufrufen
      Wrapper.Wrap.DrawImage(MyImage, 00); 



      //das hier wäre mir lieber
      //doch das geht nicht, da " Wrap " nicht erkannt wird, da sie doch nicht richtig Global ist
      Wrap.DrawImage(MyImage, 00);// <<<-------
  
    }
  }
}


Zuletzt bearbeitet von StarGazer am So 15.11.09 21:53, insgesamt 1-mal bearbeitet
Fabian E.
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 554

Windows 7 Ultimate
Visual Studio 2008 Pro, Visual Studion 2010 Ultimate
BeitragVerfasst: So 15.11.09 21:53 
Also eigentlich willst du doch nur eine Klasse anlegen deren Methoden zu aufrufen willst, oder? :?:
Das kannst du wie du selbst schon gemacht hast über das Schlüsselwort "class" machen.
Um dein Problem mit dem doppelten zu lösen könntest du die Klasse selbst als "static" deklarieren.

Fabi
Christian S.
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 20451
Erhaltene Danke: 2264

Win 10
C# (VS 2019)
BeitragVerfasst: So 15.11.09 22:05 
user profile iconStarGazer hat folgendes geschrieben Zum zitierten Posting springen:
oder wo man die Files ablegen muß um sie herreinladen zu können.

Du lädst, wie gesagt, keine Dateien (zumindest keine Quellcode-Dateien), sondern Assemblies. Das machst Du in den Referenzen. Ich glaube aber nicht, dass das ist, was Du willst. Möchtest Du einfach mehrere Quellcode-Dateien in einem Projekt, brauchst Du nichts laden.

user profile iconStarGazer hat folgendes geschrieben Zum zitierten Posting springen:
Der grund warum ich aus dem Main vieles auslagern möchte, ist, damit es im Main schön übersichtlich sauber bleibt.

Stopp! Was ist "das Main". Du hast da eine Klasse mit Feldern. Wenn diese Felder in der Klasse gebraucht werden, ist es völlig korrekt, diese innerhalb dieser Klasse zu deklarieren. Es ist eigentlich der einzige Ort, wo Du sie deklarieren kannst.

Ist Dir das zu unübersichtlich, gibt es zwei Dinge: Du kannst, wie es der Windows-Forms-Designer macht, eine "partial class" anlegen (die liegt in einem WinForms-Projekt z.B. in der Datei Form1.Designer.cs) oder Du umschließt die Felder mit "#region felder ..... #endregion" und klappst das Dingen weg ;-)

user profile iconStarGazer hat folgendes geschrieben Zum zitierten Posting springen:
Zwar erstellte er auch Klassen, es sind dann aber nur einzene Strukturen, die dann als KlassenVariable doch wieder in Main erzeutgt werden.

Den Satz kapiere ich nicht. Natürlich muss er die Klassen irgendwo instanzieren, um sie zu benutzen. Ne Klasse zu erstellen, ohne sie irgendwo zu benutzen, ist doch sinnfrei :gruebel:

user profile iconStarGazer hat folgendes geschrieben Zum zitierten Posting springen:
Ich möchte am liebsten zb für Enemys, eine eigene Klasse oder Externes File erstellen.

Was denn nun?

user profile iconStarGazer hat folgendes geschrieben Zum zitierten Posting springen:
Darin alle benötigen dinge coden, die jedoch auch auf andere externe Klassen zugreifen können müssen, und dort auch die Globalen KlassenVariablen erzeugen, und im Main mache dann einfach nur noch UpdateEnemy, und fetig ist.

Puh ... also, es gibt keine "globalen Klassenvariablen". Was Du wahrscheinlich meinst, sind Felder. Diese sind in 99% der Fälle in der .NET-Welt als "private" deklariert, gehen externe Klassen also nüschts an. Willst Du, dass eine Klasse etwas nach außen hin zur Verfügung stellt, egal ob lesend oder schreibend, machst Du das über Properties.

Interne Vorgänge einer Klasse in eine andere Klasse auszulagern, ist pöse. Mir scheint aber, dass Dir mit einer "partial class" wirklich geholfen sein könnte.

Ich möchte Dir an dieser Stelle ans Herz legen, Dich erst einmal ein bisschen mehr mit den Grundlagen zu beschäftigen, wie man in C# im speziellen und der objekt-orientierten Programmierung im allgemeinen die Dinge angeht. Du wirfst hier viele Begriffe durcheinander und einige der wichtigsten Prinzipien scheinen da auch noch zu fehlen.

Es gibt da einmal das Suche bei Google OPENBOOK VISUAL C#. Zum anderen habe ich auch mal in meiner Einführung zu Delphi Prism einiges dazu geschrieben: prismwiki.codegear.c...oriented_Programming Das ist zwar eine andere Sprache, aber es ist auch eine .NET-Sprache, sodass die allgemeinen Prinzipien exakt auch in C# gelten. Nur die Syntax ist eine andere.

_________________
Zwei Worte werden Dir im Leben viele Türen öffnen - "ziehen" und "drücken".
StarGazer Threadstarter
Hält's aus hier
Beiträge: 3



BeitragVerfasst: So 15.11.09 22:39 
@Fabian E.

das hatte ich schon versucht, geht jedoch nur wenn ich im Main doch eine dafür Varaible erzeuge.

ausblenden C#-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
static class Wrapper {}

namespace MyProject{
  public class Game1{
     Wrapper Wrap;  //<--

        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);
            
            //das geht wegen der Variabel im Main
            Wrap.DrawImage(TestImage, 00);

            //das geht leider nicht
            Wrapper.DrawImage(TestImage, 00);


mach ich jedoch auch die DrawImage Function static

ausblenden C#-Quelltext
1:
2:
3:
static class Wrapper {
}
 public static DrawImage (Texture2D texture, float x, float y)   oder so


dann gibt es wieder ärger mit
spriteBatch.Draw() -- drinnen in der Wrapper.DrawImage() Metode, da SpriteBatch() nicht static ist
oder mit
Wrapper.DrawImage(


---------------------------------------------------
@Christian S.

seid über einer Woche lese ich schon Tutorials zu CSharp durch. Nun wollte ich es endlich mal selbst versuchen.
Es bleibt wohl einem keine Wahl, man muß wohl einfach Variablen in der Main"Klasse" ^^ deklarieren
namespace Project{
..public class Game{
....Wrapper Wrap; <<<----

dann gibt es gar keine Probleme mehr. Finde es halt nicht so schön, hätte das lieber draußen gehalten.
Ich muß wohl versuchen mehre sachen in eine Klasse zu binden, wodurch diese dann in der Variable landen, damit weniger einem auf dem Screen erschlägt, oder daß mit dem ein aus blenden.



Ich werde mir mal mehr den Kopf darüber zebrechen müssen, zu Zeit qualmt er noch sehr ^^
Ich danke euch jedenfall sehr für die ausführlichen Antworten.