Forenbeiträge von Loofsy Ingesamt 32 Beiträge
Hallo zusammen,
gibt es ein NUGET-Paket um einen 3D Drucker anzusteuern also einen 3D Druckauftrag an einen 3D Drucker zu senden?
Ich habe nur eine Assambly für UWP bei Microsoft gefunden. Die hilft mir aber nicht weiter.
Hallo Zusammen,
ich möchte gerne in meiner App (Page) eine Liste List<Frame> in einem Stacklayout ausgeben.
Leider funktioneirt das nicht und ich verstehe ich wieso?
PP_Posts ist ein Stacklayout welches die Frames wiedergeben soll.
Was mache ich hier falsch?
public PostsPage()
{
InitializeComponent();
if (WordPress == null)
{
}
else
{
_pvm = new PostsViewModel(WordPress);
var v = Load();
PP_Posts.Children.Add(v);
}
}
private List<Frame> Load()
{
List<Frame> frames = new List<Frame>();
foreach(var post in _pvm.WordPress.Users)
{
var cell = new Frame
{
Content = new StackLayout
{
Children =
{
new Label
{
Text = "Test"
}
}
}
};
frames.Add(cell);
}
return frames;
}
}
Hallo liebe Mitentwickler,
das Empfangen von Push-Nachrichten über FCM bereitet mir ziemliche schwierigkeiten.
Ich habe verschiedene Implementierungen getestet jedoch hat keine so wirklich funktioniert. Die Verbindung mit FCM selber funktioniert dabei jedoch reibungslos. Ich bekomme einen Token und auch alle anderen Prüfmechanismen funktionieren. wie z.B
public bool IsPlayServicesAvailable ()
{
int resultCode = GoogleApiAvailability.Instance.IsGooglePlayServicesAvailable (this);
if (resultCode != ConnectionResult.Success)
{
if (GoogleApiAvailability.Instance.IsUserResolvableError (resultCode))
msgText.Text = GoogleApiAvailability.Instance.GetErrorString (resultCode);
else
{
msgText.Text = "This device is not supported";
Finish ();
}
return false;
}
else
{
msgText.Text = "Google Play Services is available.";
return true;
}
}
Ich bin auf der Seite https://cedgabrang.wixsite.com/xamarintipsandtricks/post/xamarin-forms-implementing-push-notification-using-firebase-cloud-messaging auf das Objekt "RemoteMessage" gestoßen in der Methode OnMessageReceived(RemoteMessage message).
ich finde jedoch keine Dokumentation darüber wie ich diese Methode aufrufen muss damit die auf eine eingehende Push-Nachricht reagiert und diese ausgibt.
Wer kann mir hier helfen?
Danke im Vorraus.
Ok na wenn ich das schon rechtlich nicht darf dann mach ich es auch erst gar nicht. Ich danke dir 🙂
vielen dank für die Antwort.
Da gebe ich dir recht und es existiert auch bereits ein Web-Backend mit einer Asyncronen verarbeitung welche mit JSON arbeitet.
Ich will nur testen ob es auch so funktioniert.
In der das ist das die Exception message. Auch bei MS ist das scheinbar nicht näher erläutert. Zumindest hab ich das nicht gefunden. Es gibt zwar google redults aber die bringen mich auch nicht wirklich weiter.
Die Exception wird bereits ausgelöst wenn die Methode Open() von MySqlConnect aaufgerufen wird. An der verbindung kann es abef nicht liegen da andefe clients die verbindung aufbauen können.
Hallo liebe Mitentwickler,
Ich bin dabei eine kleine App in Xamarin zu schreiben und mochte mit dieser nun eine MySQL datenbankverbindung aufbauen und einfach einen Simplen String aus einer Tabellenspalte (Typ VARCHAR) in einem Simplen DisplayAlert() wiedergeben lassen.
Nun wirft mir VS2019 folgende Exception "the type initializer for 'mysql.data.mysqlclient.replication.replicationmanager' threw an exception.".
Ich nutze ein von mir entwickeltes Framework (KFrame) in welchem meine MySQL Methoden implementiert sind. (hat auch immer funktioniert)
// _db.IsConnected() prüft ob eine Verbindung zur datenbank aufgebaut werden konnte (gibt true oder false zurück)
// object _db.GetValue(int,string) ruft den wert aus der datenbank ab
// else ist zu debug zwecken unbelegt
_db = new KFrameMob.Network.Database.MySQL("dummyserver", "Database", "Username", "Password"); //
if(_db.IsConnected())
{
DisplayAlert("Meldung",(string)_db.GetValue(1, "select * from app where id='1'"),"Verstanden!");
}
else
{
}
Ich habe einen Thread in einem anderen Forum mit dem Problem gefunden allerdings ist das hier scheinbar nicht die lösung
Fehler beim Aufbau einer MySQL Verbindung - breadfish.de - DIE deutschsprachige GTA-Community
Vielen Dank für die hilfe im vorraus
Hallo,
durch ein logging habe ich herrausgefunden, dass die daten zwar richtig an den server rausgehen jedoch der server die anführungszeichen entfernt.
der Folgende code ist der empfangsteil
public static void ReadCallback(IAsyncResult ar)
{
_serverOperate = new Process();
String content = String.Empty;
// Retrieve the state object and the handler socket
// from the asynchronous state object.
StateObject state = (StateObject)ar.AsyncState;
Socket handler = state.workSocket;
// Read data from the client socket.
int bytesRead = handler.EndReceive(ar);
if (bytesRead > 0)
{
// There might be more data, so store the data received so far.
state.sb.Append(Encoding.ASCII.GetString(
state.buffer, 0, bytesRead));
// Check for end-of-file tag. If it is not there, read
// more data.
content = state.sb.ToString();
if (content.IndexOf("<EOF>") > -1)
{
// All the data has been read from the
// client. Display it on the console.
//Console.WriteLine("Read {0} bytes from socket. \n Data : {1}",
// content.Length, content);
// Echo the data back to the client.
try
{
_serverOperate.StartInfo.FileName = _operationAppPath;
_serverOperate.StartInfo.Arguments = "" + DBHost + ";" + DBName + ";" + DBUserName + ";" + DBUserPassword + ";" + content;
_serverOperate.StartInfo.UseShellExecute = false;
_serverOperate.StartInfo.RedirectStandardOutput = true;
_serverOperate.Start();
StreamReader reader = _serverOperate.StandardOutput;
string output = reader.ReadToEnd();
Application.Base.SysLogger.WriteLog(output, @"H:\Test.txt"); //Speichert den empfangenen json in eine textdatei
Send(handler, output);
}
catch(Exception err)
{
Send(handler, err.Message);
}
}
else
{
// Not all data received. Get more.
handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReadCallback), state);
}
Hallo
Ich habe folgende Frage:
Ich möchte daten (Text) mittels JSON von meinem Client an einen Server Übertragen (funktioniert auch). Die Daten werden vor dem Versenden in ein Json Formatiert (funktioniert auch)
{"TEST":"datan"}
Der server empängt die anfrage und sendet diese jedoch ohne anführungszeichen zurück. Im meinem Fall wird der ankommende string einfach wieder nur zurückgeschickt.
Woran kann das liegen? Ich nutze C# und System.Text.Json.
Danke im vorraus
Danke Apt 🙂
hatte mit dem aber nix zu tun.
Sollte ein seperater thread werden. Ich habs schon den Mods gemeldet 🙂
Hallo an alle,
ich würde gerne einen string in JSON serialisieren (Klappt auch) und wieder Deserialisieren (das klappt nicht)
ich bekomme dabei den Fehler das ein illegales Zeichen um Pfad ist.
public string BaseDeserializer(string json)
{
try
{
IncomeData uld = JsonConvert.DeserializeObject<IncomeData>(json);
return uld.ApplicationName;
}
catch(Exception err)
{
string a = err.Message ;
return a;
}
}
Was mir aufgefallen ist, dass der Serialisierte JSON ('') benutzt statt("") macht das einen unterschied? wenn ja wie bekomme ich das weg?
danke im vorraus
@Abt,
wie meinst du das mit den technischen Bedingungen?
@Abt,
zunächst Danke ich dir für deine (wenn auch sehr kritisch formulierte) Antwort. Ich bin aber sicher, dass du diese nicht als persönlichen Angriff meintest daher werte ich dies auch nicht so.
Zum Thema Sicherheit: Du hast Recht! Diese weise der Programmierung ist sehr unsicher. Stell dir vor, die Daten werden sogar unverschlüsselt übertragen 😉 und das hat seinen Grund!
Die Anwendung bildet ersteinmal nur das Grundgerüst. Das Fundament sozusgen. Sie ist rein Experimentell (noch). Erstmal soll alles im Grundprinzip funktionieren. Der Ausbau und die Sicherheit kommt erst dann in den eigentlichen Testphasen und bis dahin ist es noch ein sehr sehr weiter weg. Zudem soll sie ohnehin nur für meine Privaten zwecke verwendet werden und keine Nutzerdaten übers Inet transportieren.
Die Bedingungen zum aufrufen der arbeitsanwendung stehen doch da!
Bei einer Clientanfrage empfängt der Server die Daten, öffnet das programm und leitet die Daten an das Programm weiter; anschließend wartet der Server auf die Antwort des Programms und sendet die antwort zurück an den client. das Programm schließt sich automatisch nach der abarbeitung und wird immer nur aufgerufen wenn ein Client eine anfrage sendet!
lg
Danke T-Virus,
das ".Start()" habe ich übersehen. Aber ändert leider das Problem nicht. Der gleiche fehler tritt auf.
ich habe das zwischen StreamReader oder StandartOutput geschrieben.
Hallo liebe Mitentwickler,
ich arbeite gerade an einem flexiblen Serversystem und möchte wissen ob die folgende umsetzung möglich ist.
Mein Server soll in der Lage sein, anfragen aus dem Internet (egal ob vom Handy, Tablet, PC oder what ever) aufzunehmen und zu verarbeiten. (Funktioniert auch). Nun soll er aber flexibler werden. Ich möchte nun Mehrere Serverinstanzen auf verschiedenen Ports starten (funktioniert auch) und die empfangenen Daten jedoch underschiedlich behandeln. Dazu Soll jeder Server ein jeweils eigenes Programm aufrufen, die daten übergeben und (jetzt kommt der casus knacksus) dieses Programm soll die Antwort an den Server zurückgeben und dieser an den Client zurücksenden.
Die eigentliche Client Server Communikation funktioniert auch.
Im Internet habe ich die Methode "RedirectStandartOutput" gefunden welche (so die quelle) die Antwort als Consle.WriteLine(); an den Server zurückgeben soll
_serverOperate.StartInfo.FileName = _operationAppPath; // enthält den Path des Programms welches die eigentliche Verarbeitung durchführt und die antwort an den Client ausgibt (Soll vom Server aufgerufen werden und nach der Antwortausgabe wieder geschlossen werden)
_serverOperate.StartInfo.Arguments = ""+DBHost+";"+DBName+";"+DBUserName+";"+DBUserPassword+";"+content; // content enthält einen JSon string
_serverOperate.StartInfo.UseShellExecute = false;
_serverOperate.StartInfo.RedirectStandardOutput = true;
StreamReader reader = _serverOperate.StandardOutput;
string output = reader.ReadToEnd();
Send(handler, output); // sendet die daten an den Client zurück
Ich bekomme jedoch eine Exeption ausgegeben > Fehlermeldung:
"System.InvalidOperationException: StandartOut wurde nicht Umgeleitet, oder der Prozess wurde noch nicht gestartet."
Nun ist meine Frage: Leide ich an Programmierblindheit oder ist das so wie ich das umsetzen möchte gar nicht möglich und och habe die Methode falsch verstanden?
Vielen Dank im Vorraus
Hallo liebe Mitentwickler,
ich habe folgende frage:
Ich habe ein Client Serversystem entwickelt. Dieses soll nun die Möglichkeit haben verschiedene Objekte wie String, Integers, oder auch DataSet´s zum client zu senden.
dazu ist es (für mich) wichtig das die ankommenden Daten (als ByteArray) als object zu konvertieren.
Die derzeitige Lösung überführt das Array jedoch in einen String was nicht sein soll.
Encoding.ASCII.GetString(state.buffer, 0, bytesRead)
Um die Zwischenschritte zu Dokumentieren habe ich kein kleines Loggongprogramm geschrieben.
Nun Passiert folgendes:
wenn mein Client nun daten aus einer Datenbank (MS SQL) benötigt, sendet er die Anfrage an seinen Server. Der server wiederrum kommuniziert mit der Datenbank und sendet nun die erhalltenen Daten zurück an den Client.
Wenn ich nun ein DataGridView mit diesen Daten füllen will, versuche ich das so:
dgv1.DataSource = _client.RequestToServer(sqlString); //RequestToServer ist vom Datentyp object
der Server soll nun ein DataSet übermitteln!
Laut dem ankommenden Logdaten kommt jedoch nur der String "Table" zurück. Wie kann ich also das ByteArray in object convertieren um das opject dann später als DataSet zu convertieren?
vielen dank für die Hilfe.
Hallo,
ich versuche mich gerade an meiner ersten Xamarin App. Nachdem ich auf der default Page (die von Visual Studio generiert wurde) ein bisschen Experimentiert habe, möchte ich nun den Content nicht über XAML schreiben sondern zb. einen Text oder Content zb aus einer MSSQL oder MySQL Datenbank holen.
Ich scheitere jedoch bereits daran, dass ich es nicht mal schaffe, ein einfaches Label über eine ViewModel darzustellen.
Mein C# Code:
using System;
using System.Windows.Input;
using Xamarin.Essentials;
using Xamarin.Forms;
namespace MyApp.ViewModels
{
public class AboutViewModel : BaseViewModel
{
public AboutViewModel()
{
//Title = "About";
OpenWebCommand = new Command(async () => await Browser.OpenAsync("https://aka.ms/xamarin-quickstart"));
}
public ICommand OpenWebCommand { get; }
public void Display()
{
StackLayout al = new StackLayout
{
Children =
{
new Button
{
Text = "Test",
TextColor = Color.Red,
}
}
};
}
}
}
Ich weiss bereits das die Methode Display() an die Property MainPage in der class App übergebenwerden muss (da wo standart nur AppShell() übergeben wird (MainPage = new AppShell()😉
Wenn ich das aber (unter einbindung der class AboutViewModel) mache bekomme ich keinen Inhalt angezeigt. Eigentlich sollte ein Label mit "Test" in Roter Schriftfarbe angezeigt werden.
Auf binded-viewmodel-content-to-stacklayout habe ich zwar die einbindung über XAML gefunden:.....
<ContentPage x:Name="ParentView">
<ScrollView x:Name = "CategoriesScrollView">
<controls:CustomStackLayout Orientation="Horizontal" Spacing="20" Items = "{Binding BindingContext.CategoryName, Source={x:Reference ParentView}}" />
</ScrollView>
... verstehe aber nicht WO der punkt ist im zb. Display() einzufügen
wär super wenn mir da jemand helfen könnte
lg
Hallo liebe Community,
ich entwickle gerade eine Firmenlösung auf WPF Basis. In meinem Hauptfenster gibt es eine Menüleiste welche ich so eingestellt hab, dass Mitarbeiter sich erst einloggen müssen ehe sie von den Menüreitern gebrauch machen können.
<Window x:Class="Delphin.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:local="clr-namespace:Delphin"
mc:Ignorable="d"
Title="MainWindow" Height="768" Width="1024" WindowStartupLocation="CenterScreen" WindowState="Maximized" ResizeMode="NoResize">
<Grid>
<DockPanel LastChildFill="False">
<Menu DockPanel.Dock="Top" x:Name="Menu">
<Menu.Background>
<LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
<GradientStop Color="White" Offset="0"/>
<GradientStop Color="#FF54DFE6" Offset="1"/>
</LinearGradientBrush>
</Menu.Background>
<MenuItem Header="Datei" >
<MenuItem Header="Anmelden" x:Name="Menu_File_Logon" Click="Menu_File_Logon_Click" />
<MenuItem Header="Abmelden" x:Name="Menu_File_Logoff" Click="Menu_File_Logoff_Click" />
<MenuItem Header="Beenden" x:Name="Menu_File_Exit" Click="Menu_File_Exit_Click" />
</MenuItem>
<MenuItem Header="Mitarbeiter" x:Name="Menu_Employee">
</MenuItem>
<MenuItem Header="Kunde" x:Name="Menu_Customer">
</MenuItem>
<MenuItem Header="Produkte" x:Name="Menu_Products">
</MenuItem>
<MenuItem Header="Webseite" x:Name="Menu_Website">
</MenuItem>
<MenuItem Header="Firma" x:Name="Menu_Company">
</MenuItem>
<MenuItem Header="Einstellungen" x:Name="Menu_Settings">
</MenuItem>
<MenuItem Header="Hilfe" x:Name="Menu_Help">
</MenuItem>
</Menu>
</DockPanel>
<Canvas>
<Frame x:Name="MainContent" Height="718" Width="1018" Canvas.Top="21"/>
</Canvas>
</Grid>
</Window>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using Delphin.View.File;
using Delphin.ViewModels;
using Delphin.Res.Includes;
namespace Delphin
{
/// <summary>
/// Interaktionslogik für MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
private SystemConfig _sc; // läd im wesentlichen die Property public bool IsUserLoggedOn {get; set;} dessen wert Standart false ist
public MainWindow()
{
InitializeComponent();
StdLoad();
_sc = new SystemConfig();
}
private void StdLoad()
{
Menu_Employee.IsEnabled = false;
Menu_Customer.IsEnabled = false;
Menu_Products.IsEnabled = false;
Menu_Website.IsEnabled = false;
Menu_Company.IsEnabled = false;
Menu_Settings.IsEnabled = false;
Menu_Help.IsEnabled = false;
Menu_File_Logoff.IsEnabled = false;
}
public void Update()
{
Menu_File_Exit.IsEnabled = false;
Menu_File_Logon.IsEnabled = false;
Menu_Employee.IsEnabled = _sc.IsUserLoggedOn;
Menu_Customer.IsEnabled = _sc.IsUserLoggedOn;
Menu_Products.IsEnabled = _sc.IsUserLoggedOn;
Menu_Website.IsEnabled = _sc.IsUserLoggedOn;
Menu_Company.IsEnabled = _sc.IsUserLoggedOn;
Menu_Settings.IsEnabled = _sc.IsUserLoggedOn;
Menu_Help.IsEnabled = _sc.IsUserLoggedOn;
Menu_File_Logoff.IsEnabled = _sc.IsUserLoggedOn;
Menu.UpdateLayout();
}
private void Menu_File_Logon_Click(object sender, RoutedEventArgs e)
{
MainContent.Content = new LogonPage();
}
private void Menu_File_Logoff_Click(object sender, RoutedEventArgs e)
{
}
private void Menu_File_Exit_Click(object sender, RoutedEventArgs e)
{
}
}
}
Nun zu meinem Problem. Wenn man Datei->Anmelden anklickt wird das Anmeldeformular geladen. Siehe:
<Page x:Class="Delphin.View.File.LogonPage"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:local="clr-namespace:Delphin.View.File"
mc:Ignorable="d"
d:DesignHeight="768" d:DesignWidth="1024"
Title="LogonPage"
>
<Grid>
<Canvas>
<TextBox Height="23" Canvas.Left="393" TextWrapping="Wrap" Canvas.Top="201" Width="120"/>
<PasswordBox Canvas.Left="393" Canvas.Top="238" Width="120" Height="23"/>
<Label Content="Benutzerkennung" Canvas.Left="250" Canvas.Top="197"/>
<Label Content="Passwort" Canvas.Left="295" Canvas.Top="235"/>
<Button Content="Anmelden" Click="Logon_Btn_Logon" Canvas.Left="393" Canvas.Top="285" Width="120"/>
</Canvas>
</Grid>
</Page>
Logon_Btn_Logon löst DoLogon() aus und soll nun die gesperrten Menüelemente freigeben:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Delphin.Res.Includes;
namespace Delphin.ViewModels.File
{
public class LogonPageModel
{
private SystemConfig _sc;
private MainWindowModel _mwm;
public LogonPageModel()
{
_sc = new SystemConfig();
_mwm = new MainWindowModel();
}
public void DoLogon()
{
_sc.IsUserLoggedOn = true;
SetLogon();
}
public void SetLogon()
{
/**
public void Update()
{
Menu_File_Exit.IsEnabled = false;
Menu_File_Logon.IsEnabled = false;
Menu_Employee.IsEnabled = _sc.IsUserLoggedOn;
Menu_Customer.IsEnabled = _sc.IsUserLoggedOn;
Menu_Products.IsEnabled = _sc.IsUserLoggedOn;
Menu_Website.IsEnabled = _sc.IsUserLoggedOn;
Menu_Company.IsEnabled = _sc.IsUserLoggedOn;
Menu_Settings.IsEnabled = _sc.IsUserLoggedOn;
Menu_Help.IsEnabled = _sc.IsUserLoggedOn;
Menu_File_Logoff.IsEnabled = _sc.IsUserLoggedOn;
Menu.UpdateLayout();
}
\*/
_mwm.Update();
}
}
}
Doch die schaltung auf Enable funktioniert nicht. Leider wird auch keine Fehlermeldung ausgegeben. Woran liegt das?
Also kurz zusammengefast: Die Menüelemente sind standart IsEnable=false. Nach dem Click auf "Anmelden" sollen die Elemete auf IsEnable=true schalten.
Danke im vorraus
Hallo liebe Mitentwickler.
Ich habe meine Serverklasse soweit fertig (funktioniert im wesentlichen auch). Allerdings mit einer kleinen aber problematischen Einschränkung.
Nachdem der Socket die Verbindung angenommenhat, sollen die werte von _socket1.Available in int chach1 geschrieben werden (int cache1 = _socket1.Available😉
Im Debugmodus von VS 2019 funktioniert dies solange man mit haltepunkten schrit für schritt über diese zeile geht. Nimmt man die Haltepunkte weg oder lässt das Programm so durchlaufen werden die werte aus _socket1.Available nicht übernommen (obwohl sie da sind). Weiss einer woran das liegt bzw wie man das beheben kann?
Ich habe bereits versucht mit Thread.Sleep(1000); mehrere "Wartepunkte" zu erstellen weil ich vermute dass das programm zu schnell abgearbeitet wird aber daran liegt es nicht.
Nachfolgend der ganzze code und danke im Vorraus.
public ServerEngine()
{
IPHostEntry ipHostInfo = Dns.Resolve("MUSTER-PC");
IPAddress ipAddress = ipHostInfo.AddressList[2];
Controller._serverIPEndPoint = new IPEndPoint(ipAddress, 9090);
Controller._listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
}
public void ServerRun()
{
try
{
Controller._listener.Bind(Controller._serverIPEndPoint);
Controller._listener.Listen(10000);
Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
Protocoll.Write($"");
Protocoll.Write($"PRTW-Server gestartet!");
Protocoll.Write($"");
Protocoll.Write($"##########################################################");
Thread run = new Thread(() =>
{
byte[] _receivePufferSize;
while (true)
{
Socket _socket1 = Controller._listener.Accept(); // wartet auf eingehende Verbindungy
int cache1 = _socket1.Available; // Legt Empfangswert in zwischenspeicher
if (cache1 == _socket1.Available) // Prüfung ab Daten korrekt empfangen wurden.
{
_receivePufferSize = new byte[cache1];// festlegen des Empfangsspeichers
_receivePuffer = _socket1.Receive(_receivePufferSize); // empfangen der Daten
_content = Encoding.ASCII.GetString(_receivePufferSize, 0, _receivePuffer); // Übersetzen in String
#region Zerlegen der eingehenden Information (sofern das Format stimmt)
//Format ClientName:ServiceName:Identifier:Command
string[] values;
string clientName;
string serviceName;
string identifier;
string command;
string param = _content;
string connectParam;
values = param.Split(':');
if (values.Length == 4) // Prüft ob das Format korrekt ist
{
// Weisst die Arraywwerte den Variablen zu
clientName = values[0];
serviceName = values[1];
identifier = values[3];
command = values[2];
#endregion
#region Eingehende Anfrage wird gefiltert und sortiert
if (identifier == "195c40c4-842d-4e72-ad29-fd6b16c9e4aa" && clientName != "PRTG_Client")
{
Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
Protocoll.Write($"");
Protocoll.Write($"Der Dienst -> {serviceName} <- möchte sich anmelden!");
Protocoll.Write($"");
Protocoll.Write($"##########################################################");
if (ClientLister._TWPro_ClientRequestList.ContainsKey(serviceName)) // Prüft ob TWPro_Dienst bereits angemeldet ist.
{
Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
Protocoll.Write($"");
Protocoll.Write($"Der Dienst -> {serviceName} <- hat sich bereits angemeldet!");
Protocoll.Write($"");
Protocoll.Write($"##########################################################");
}
else // Wenn nicht, melde Dienst an
{
Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
Protocoll.Write($"");
Protocoll.Write($"Der Dienst -> {serviceName} <- wurde angemeldet!");
Protocoll.Write($"");
Protocoll.Write($"##########################################################");
ClientLister._TWPro_ClientRequestList.Add(serviceName, _socket1);
}
}
if (identifier == "195c40c4-842d-4e72-ad29-fd6b16c9e4aa" && clientName == "PRTG_Client")
{
Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
Protocoll.Write($"");
Protocoll.Write($"PRTG ruft {serviceName}!");
Protocoll.Write($"");
Protocoll.Write($"##########################################################");
if (ClientLister._TWPro_ClientRequestList.ContainsKey(serviceName))
{
Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
Protocoll.Write($"");
Protocoll.Write($"Der Dienst -> {serviceName} <- wurde gefunden...");
Protocoll.Write($"{command} wurde übertragen!");
Protocoll.Write($"");
Protocoll.Write($"##########################################################");
Socket ip = (Socket)ClientLister._TWPro_ClientRequestList[serviceName];
try
{
if (ip.Connected) // Prüfe ob verbindung zum TWPro-Dienst besteht
{
// Sende Anfage an TWPro Dienst
byte[] sendPuffer = Encoding.ASCII.GetBytes(command);
ip.Send(sendPuffer);
Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
Protocoll.Write($"");
Protocoll.Write($"{command} wurde an {ip.RemoteEndPoint} gesendet!");
Protocoll.Write($"Warten auf antwort.......");
Protocoll.Write($"");
Protocoll.Write($"##########################################################");
// Empfange Antwort vom TWPro Dienst
int cache = ip.Available;
_receivePufferSize = new byte[cache];
_receivePuffer = ip.Receive(_receivePufferSize);
string receiveMsg = Encoding.ASCII.GetString(_receivePufferSize, 0, _receivePuffer);
Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
Protocoll.Write($"");
Protocoll.Write($"{receiveMsg} wurde von {ip.RemoteEndPoint} empfangen!");
Protocoll.Write($"Sende antwort an PRTG");
Protocoll.Write($"");
Protocoll.Write($"##########################################################");
// Sende Antwort an PRTG_Client
_socket1.Send(_receivePufferSize);
// byte[] sendPuffer2 = Encoding.ASCII.GetBytes(_receivePuffer);
}
else // wenn nicht sende Fehler und entferne Dienst aus der Liste
{
byte[] sender = Encoding.ASCII.GetBytes("false:2:TWPro-Dienst antwortet nicht!");
_socket1.Send(sender);
ClientLister._TWPro_ClientRequestList.Remove(serviceName);
}
}
catch (Exception e)
{
Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
Protocoll.Write($"");
Protocoll.Write($"Fehler bei der kommunikation!");
Protocoll.Write($"");
Protocoll.Write($"##########################################################");
}
}
else
{
Protocoll.Write($"######### Protokoll { DateTime.Now.ToString("G")}#########");
Protocoll.Write($"");
Protocoll.Write($"Der Dienst -> {serviceName} <- wurde nicht gefunden!");
Protocoll.Write($"Sende Fehler an PRTG");
Protocoll.Write($"");
Protocoll.Write($"##########################################################");
string cont = "false:" + PRTG_Code.ReturnInfo((short)PRTG_Code.PRTG_Code_Enum.WARNING) + "," + SystemMessages.ServerMessages((short)SystemMessages.ServerCode.ClientNotConnect) + "";
byte[] sendPuffer = Encoding.ASCII.GetBytes(cont);
_socket1.SendTo(sendPuffer, _socket1.RemoteEndPoint);
}
}
#endregion
}
else
{
byte[] errSend = Encoding.ASCII.GetBytes("false:4:Ungültiges Format!");
_socket1.Send(errSend);
}
}
else
{
byte[] errSend = Encoding.ASCII.GetBytes("false:4:Fehler beim Datenempfang!");
_socket1.Send(errSend);
}
}
});
run.Start();
}
catch (Exception e)
{
Protocoll.Write($"{e.Message}");
}
}
hat sich erledigt. Danke für die Hilfe 🙂
Hi,
gibt es eine möglichkeit eine TCP Verbindung aufrecht zu erhalten?
Zb. ein Client meldet sich beim Server an und "Wartet" bis er von einem anderen Client eine Anfrage bekommt. ähnlich wie in einem Chat.
Lg
In der Tat habe ich mir auch schon die Async Variante angesehen. Allerdings auf der MS Doc seite Asynchrone Programmierung in C#
.
Soweit ich das verstanden habe sorgt async dafür, dass vorgänge Paralel abgearbeitet werden und bei sync wird jede Anfrage nacheinander abgearbeitet.
Ich habs bereits gemerkt XD. Das ist ein echtes Brett
Hallo liebe Mitentwickler,
ich dabei einen Server zu entwickeln, welcher anfragen von Clients aufnimmt und weiterleitet sowie die antwort an den anfragenden Client zurückgibt. So als eine Art "Router".
Der Server selber im Grundgerüst (als Dienst funktioniert)
Anbei etwas Code: Das Auskommentierte kann ignoriert werden.
Code der Dienststeuerung (Start und Stopp)
namespace Server
{
public partial class ServerService : ServiceBase
{
#region ServerControlls
public ServerService()
{
InitializeComponent();
}
protected override void OnStart(string[] args)
{
StartUP();
}
protected override void OnStop()
{
}
#endregion
#region Backend
internal void StartUP()
{
ServerEngine serverEngine = new ServerEngine(9090);
// WorkerTasks.IncomingRequest(serverEngine);
//Thread iRT = new Thread(WorkerThreads.IncomingRequestThread);
//iRT.Start(serverEngine);
//Thread cWT = new Thread(WorkerThreads.ClientWorkingThread);
//cWT.Start();
//Thread rT = new Thread(WorkerThreads.RoutingThread);
//rT.Start();
}
#endregion
}
}
Code der Server Engine (Das eigentliche Serverprogramm)
namespace Server
{
/// <summary>
/// Beinhaltet alle Methoden für die Serververbindung
/// </summary>
public class ServerEngine
{
#region Parameter
private int _port;
public TcpListener _tcpServerListener;
public static TcpClient _tcpServerClient;
public IPEndPoint _serverIPEndPoint;
public Socket _serverSocket;
public IPAddress _serverIPAdress;
public IPHostEntry _serverIPHost;
public static NetworkStream _networkStream;
public static ClientLister _cl;
public static string _data;
#endregion
#region Konstruktor
public ServerEngine(int port)
{
int maxUserPerServer = 1000;
_port = port;
_serverIPHost = Dns.GetHostEntry(Dns.GetHostName());
_serverIPAdress = _serverIPHost.AddressList[3];
_serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_serverIPEndPoint = new IPEndPoint(_serverIPAdress, _port);
_tcpServerListener = new TcpListener(_serverIPEndPoint);
_tcpServerListener.Start();
//_tcpServerListener.Server.Bind(_serverIPEndPoint);
//_tcpServerListener.Server.Listen(maxUserPerServer);
_cl = new ClientLister();
}
#endregion
#region public Methods
/// <summary>
/// Empfängt alle Anfragen an den Server und Speichert diese in einer Liste.
/// </summary>
public static void Receiver(object server)
{
_tcpServerClient = new TcpClient();
if (((ServerEngine)server)._tcpServerListener.Pending()) // Prüft ob eingehende Anfragen vorliegen
{
_tcpServerClient = ((ServerEngine)server)._tcpServerListener.AcceptTcpClient(); // Nimmt die eingehende Anfrage an!
// Interne Methodenvariablen //
string[] saveIncomeData;
string substrg;
byte[] _receiverPuffer = new byte[_tcpServerClient.Available];
//////////////////////////////////
if (_receiverPuffer.Length < 1) // prüft ob Daten empfangen wurden; wenn nicht löse fehler aus!
{
Protocoll.Write($"Es wurden keinen Daten von { _tcpServerClient.Client.RemoteEndPoint } übergeben! ");
}
else
{
_networkStream = _tcpServerClient.GetStream();// Ruft den Netzwerkstream ab
////// Empfängt Daten vom Client
_networkStream.Read(_receiverPuffer, 0, _tcpServerClient.Available);
_data = Encoding.ASCII.GetString(_receiverPuffer);
_cl.AddIncomingRequest(_tcpServerClient.Client.RemoteEndPoint, _data); // Speichert eingehende Verbindung
Protocoll.Write($"{_tcpServerClient.Client.RemoteEndPoint},,, {_data}");
Protocoll.Write($"{_cl.CountIncomingRequest()}");
}
}
}
/// <summary>
/// Prüft ob sich Clients am Server angemeldet haben
/// </summary>
/// <returns></returns>
public static bool IsContainedValues()
{
if(_cl.CountIncomingRequest()>0)
{
return true;
}
else
{
return false;
}
}
public static bool Handshake()
{
try
{
if(_data != null)
{
string[] splitData = _data.Split(':');
string[] splitData2 = splitData[0].Split('-');
}
return true;
}
catch(Exception Err)
{
return false;
}
}
#endregion
}
}
Der Kostruktor beinhaltet den eigentlichen Server. Die Methode "Receiver()" ist für den Datenempfang zuständig.
Nun mein Problem:
Der Server soll nun ständig auf anfragen warten und sobald eine eingeht soll diese in einem seperaten Thread ausgelagert werden und dort weiterverarbeitet werden, sodass der server sofort für die nächste Anfrage bereit ist.
Ich habe versucht den Thread in der SartUP Medhode des ServerService zu implementieren:
Thread iRT = new Thread(WorkerThreads.IncomingRequestThread);
iRT.Start(serverEngine);
zur Kontrolle habe ich eine Protokollmethode geschrieben die mir die Zwischenergebnisse zeigt. Leider ohne erfolg. Auch habe ich versucht den eigentlichen Speichervorgang (für die Clients) in einem Task auszulagern. Siehe wie Folgt:
public static class WorkerThreads
{
public static void IncomingRequestThread(object serverEngine)
{
WorkerTasks.IncomingRequest(serverEngine);
}
}
public static class WorkerTasks
{
#region Parameter
#endregion
public static void IncomingRequest(object serverEngine)
{
Task _workTask = Task.Run(() =>
{
Protocoll.Write($"Incoming tread 1"); // Kontrollpunkt für mich selbst
ServerEngine.Receiver(serverEngine);
});
}
}
Leider war auch das nicht von erfolg gekrönt.
Ich weiss das es viel Code ist und ich habe versucht es übersichtlich und verständlich wie möglich zu formulieren.
Vllt ist der Begriff "Handshake" inkorrekt.
Der Prozess soll im Wesentlichen folgendes machen.
- Starte Server -> Server wartet auf anfrage
- Client sendet Anfrage an den Server (inhalt: Clientname und einen Identifier)
- Server nimmt Anfrage entgegen und prüft ob sich der Client anmelden darf. Ist das der Fall geht der Client sammt Tcp-Verbindung in den Cache (in meinem Fall ein Dictionary)
- Client sendet nun anfrage an anderen Client und der Server leitet die anfrage weiter.
- Angefragter Client verarbeitet die Anfrage und sendet antwort über den Server an den Anfragenden Client.
soll soll der grobe Ablauf sein.
syntaktisch genauso.
Ich lösche den Panelinhalt mit Clear(); und füge den neuen Inhalt mit Add(form) ein.
Hallo liebe Mitentwickler,
ich stehe vor einem verständnisproblem.
Ich Habe eine Hauptanwendung (Muster.exe) und eine DLL (MuserForm.DLL).
Meine Muster.exe gibt ein WindowsForm "MainWindow.cs" aus welches ein Panel enthällt. Dieses Panel soll alle Formulare ausgeben welche der Nutzer haben möchte (Zb. Kalender oder Notizen)
Wenn ich die entsprechenden UserControlls mit:
MainWindow.Panel1.Controls.Clear();
MainWindow.Panel1.Controls.Add(form);
aufrufe funktioniert der Formularwechsel reibungslos. Soweit sogut.
Ich habe die DLL über Verweise (Nutze VS 2019 Enterprise) eingefügt und über
using
bekannt gemacht und möchte jetzt die UserControls der DLL in meinem Panel der MainForm.exe aufrufen (zb. via Button). Dies funktioniert jedoch nicht.
der Button selber scheint jedoch io da er ohne weiteres eine MessageBox ausgibt. Ich sollte vllt noc dazu erwähnen: Das UC Form mit dem Button befindet sich bereits in der DLL.
Nun Frage ich mich warum funktioniert der Formwechsel in der exe, aber nicht in der DLL?
Danke im vorraus
Ich arbeite als Softwareentwickler C# und habe den Auftrag erhalten einen Handshake zu entwickeln. Leider darf ich auf die Details nicht eingehen aber soviel kann ich sagen.
Es wird keine Websache entwickelt. Allgeimein gesprochen soll ein Serverdienst laufen (läuft auch) welcher auf Clients zum anmelden wartet. Der Verbindungsaufbau an sich funktioniert und auch der Datenaustausch.
Nun soll sich der Client erst anmelden und und der Server (Dienst) die Anmeldung bestätigen.
Hallo,
ich bin dabei ein Server-Client system zu entwickeln. Die eigentliche Verbindung und Datenkommunikation funktioniert auch. Nun möchte ich, dass sich die Clients per Handshake authentifizieren.
Über google konnte ich nur eine C# methode für einen Seriellen Port finden. Diese hilft mir jedoch nicht.
Wie kann ich einen Handshake für ein TCP Netzwerk entwickeln?
Vielen Dank im vorraus.
Hallo,
ich habe ein WPF Haupseite erstellt mit Menü usw. Funktioniert auch alles soweit tadellos. Nun habe ich aber folgende herrausforderung.
Wenn ich Zb über das Menü eine Seite (Page.xaml) aufrufe, öffnet sich diese. Wenn ich danach jedoch über das Menü eine andere Seite (Page2.xaml) aufrufen möchte passiert überhaupt nichts.
Zum besseren verständnis hier der code der Menübuttons:
private void Menu_CRM_Kundensuche(object sender, RoutedEventArgs e)
{
Kundensuche ks = new Kundensuche();
this.Content = ks;
}
private void Menu_CRM_Kundenakte(object sender, RoutedEventArgs e)
{
FormKundenakte ka = new FormKundenakte();
this.Content = ka;
}
Die einzelnen Button funktionieren für sich. Allerdings muss das Programm jedes mal neu gestartet werden. Meine Frage ist daher. Wie erreiche ich den Pagewechsel?
Danke im Vorraus
Hallo,
ich habe eine Aufgabe bei der ich nicht mehr weiter komme. Vorab der Code. Unten schreibe ich die Details.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.IO;
namespace ESA_Projekt
{
public delegate void TransponderDel(string kennung, Position pos);
interface ITransponder
{
void Transpond(string kennung, Position pos);
}
enum Airbus : short { A300, A310, A318, A319, A320, A321, A330, A340, A380, Boeing_717, Boeing_737, Boeing_747, Boeing_777, Boeing_BBJ }
public struct Position
{
public int x, y, h;
public Position(int x, int y, int h)
{
this.x = x;
this.y = y;
this.h = h;
}
public void PositionÄndern(int deltaX, int deltaY, int deltaH)
{
x = x + deltaX;
y = y + deltaY;
h = h + deltaH;
}
public void HöheÄndern(int deltaH)//Aufruf in Sinken/Steigen
{
h = h + deltaH;
}
}
abstract class Luftfahrzeug
{
public string kennung;
public string Kennung
{
protected set { kennung = value; }
get { return kennung; }
}
private int sitzplätze;
private int fluggäste;
public int Fluggäste
{
set
{
if (sitzplätze < (fluggäste + value))
Console.WriteLine("Keine Buchung: Die " + "Fluggastzahl würde mit der Zubuchung " + "von {0} Plätzen die verfügbaren Plätze "
+ "von {1} um {2} übersteigen!", value, sitzplätze, value + fluggäste - sitzplätze);
else
fluggäste += value;
}
get { return fluggäste; }
}
public Position pos;
public abstract void Steigen(int meter);
public abstract void Sinken(int meter);
}
class Flugzeug : Luftfahrzeug
{
public Position zielPos;
protected int streckeProTakt;
protected int flughöhe;
protected int steighöheProTakt;
protected int sinkhöheProTakt;
protected bool steigt = false;
protected bool sinkt = false;
public void Starte(Position zielPos, int streckeProTakt, int flughöhe, int steighöheProTakt, int sinkhöheProTakt)
{
// neu Lektion 3
this.zielPos = zielPos;
this.streckeProTakt = streckeProTakt;
this.flughöhe = flughöhe;
this.steighöheProTakt = steighöheProTakt;
this.sinkhöheProTakt = sinkhöheProTakt;
this.steigt = true;
}
public Flugzeug(string kennung, Position startPos)
{
this.kennung = kennung;
this.pos = startPos;
}
public override void Steigen(int meter)
{
pos.HöheÄndern(meter);
Console.WriteLine(kennung + "steigt " + meter + "Meter, Höhe =" + pos.h);
}
public override void Sinken(int meter)
{
pos.HöheÄndern(-meter);
Console.WriteLine(kennung + "sinkt " + meter + "Meter, Höhe =" + pos.h);
}
}
class Starrflügelflugzeug : Flugzeug, ITransponder
{
public Starrflügelflugzeug(string kennung, Position startPos) : base(kennung, startPos)
{
//Program.transponder += new TransponderDel(Transpond);
Program.transponder += Transpond;
}
public void Transpond(string kennung, Position pos)
{
double abstand = Math.Sqrt(Math.Pow(this.pos.x - pos.x, 2) + Math.Pow(this.pos.y - pos.y, 2));
//if (kennung.Equals(this.kennung))
// Console.WriteLine("{0} an Position x={1}, y={2}, h={3}", kennung, pos.x, pos.y, pos.h);
DateTime timestamp = DateTime.Now;
if (kennung.Equals(this.kennung))
{
Console.Write("{0}:{1}", timestamp.Minute, timestamp.Second);
Console.Write("\t{0}-Position: {1}-{2}-{3}", this.kennung, base.pos.x, base.pos.y, base.pos.h);
Console.Write("Zieldistanz: {0} m\n", Zieldistanz());
}
else
{
Console.Write("\t{0} ist {1} m von {2} entfernt.\n", this.kennung, (int)abstand, kennung);
if (Math.Abs(this.pos.h - pos.h) < 100 && abstand < 500)
Console.WriteLine("\tWARNUNF: {0} hat nur {1} m Höhenabstand!", kennung, Math.Abs(this.pos.h - pos.h));
}
}
// Neu Lektion 3
double a, b, alpha, a1, b1;
bool gelandet = false;
private bool SinkenEinleiten()
{
double strecke = Math.Sqrt(Math.Pow(streckeProTakt, 2) - Math.Pow(sinkhöheProTakt, 2));
int sinkstrecke = (int)(strecke * (pos.h - zielPos.h) / sinkhöheProTakt);
int zieldistanz = Zieldistanz();
if (sinkstrecke >= zieldistanz)
{
//optinale Consolenausgabe zur Kontrolle
Console.WriteLine("{0} Sinkstrecke {1} >= Zieldistanz {2}", kennung, sinkstrecke, zieldistanz);
return true;
}
else
return false;
}
// Beim Sinkflug ist ein negativer Wert für den zweiten
// Parameter anzugeben.
private void PositionBerechnen(double strecke, int steighöheProTakt)
{
// modifizierte Übernahme der bisherigen Berechungen aus "Steuern"
a = zielPos.x - pos.x;
b = zielPos.y - pos.y;
alpha = Math.Atan2(b, a);
a1 = Math.Cos(alpha) * strecke;
b1 = Math.Sin(alpha) * strecke;
pos.PositionÄndern((int)a1, (int)b1, steighöheProTakt);
}
private int Zieldistanz()
{
return (int)Math.Sqrt(Math.Pow(zielPos.x - pos.x, 2) + Math.Pow(zielPos.y - pos.y, 2));
}
public void Steuern()
{
if (steigt)
{
if (this.SinkenEinleiten())
{
steigt = false;
sinkt = true;
}
else if (pos.h > flughöhe)
{
steigt = false;
}
}
else if (sinkt)
{
if (pos.h <= zielPos.h + sinkhöheProTakt)
gelandet = true;
}
else
{
//Horizontalflug
if (this.SinkenEinleiten())
{
sinkt = true;
}
}
if (!gelandet)
{
// Zunächst die aktuelle Position ausgeben:
Program.transponder(kennung, pos);
//"Strecke" (am Boden) berechnen:
if (steigt)
{
double strecke = Math.Sqrt(Math.Pow(streckeProTakt, 2) - Math.Pow(steighöheProTakt, 2));
this.PositionBerechnen(strecke, steighöheProTakt);
}
else if (sinkt)
{
double strecke = Math.Sqrt(Math.Pow(streckeProTakt, 2) - Math.Pow(sinkhöheProTakt, 2));
this.PositionBerechnen(strecke, -sinkhöheProTakt);
}
else
{
// im Horizontalflug ist "strecke" gleich "streckeProTakt"
this.PositionBerechnen(streckeProTakt, 0);
}
}
else
{
// Flieger derigistrieren, Transponder abschalten, Abschlussmeldung
Program.fliegerRegister -= this.Steuern;
Program.transponder -= this.Transpond;
Console.WriteLine("\n{0} gelandet (Zieldistanz={1}, Höhendistanz={2}", kennung, Zieldistanz(), pos.h - zielPos.h);
}
}
}
class Düsenflugzeug : Starrflügelflugzeug
{
// CSH03 Lektion 5
public Airbus typ;
private int sitzplätze;
public Düsenflugzeug(string kennung, Position startPos) : base(kennung, startPos)
{
bool initialized = this.Starte();
if (initialized)
{
Program.transponder += this.Transpond;
Program.fliegerRegister += this.Steuern;
}
}
public void SchreibeProtokoll( string kennung, Position startPos)
{
string DoW = DateTime.Now.DayOfWeek.ToString();
string HoD = DateTime.Now.Hour.ToString();
string MoD = DateTime.Now.Minute.ToString();
string SoD = DateTime.Now.Second.ToString();
string headerContent;
string LogPath;
LogPath = @"C:\Users\MyName\source\repos\ESA_CSH03B\ESA_Projekt\bin\Debug\" + kennung + "_" + DoW + "-" + HoD + "-" + MoD + "-" + SoD + ".bin";
headerContent = "Flug " + kennung + " (Typ " + typ + ") startet an Position " + startPos.x + "-" + startPos.y + "-" + startPos.h + " mit Zielposition " + zielPos.x + "-"+ zielPos.y +"-"+ zielPos.h +".";
BinaryWriter writer = new BinaryWriter(File.Open(LogPath, FileMode.Create));
writer.Write(headerContent);
while(pos.x != null)
{
Console.WriteLine(" Testmarker" + pos.x +","+ pos.y +"," + pos.h +"");
Console.ReadLine();
}
writer.Close();
}
public bool Starte()
{
string pfad = @"C:\Users\MyName\source\repos\ESA_CSH03B\ESA_Projekt\" + kennung + ".init";
StreamReader reader;
try
{
reader = new StreamReader(File.Open(pfad, FileMode.Open));
}
catch (IOException e)
{
Console.WriteLine("{0} Fehler beim Zugriff auf die Datei " + pfad, e.GetType().Name);
return false;
}
int[] data = new int[9];
for (int i = 0; i < 9; i++)
{
string str = reader.ReadLine();
str = str.Substring(str.IndexOf('=') + 1);
//Zur Kontrolle, später auskommentieren
//Console.WriteLine(str);
data[i] = Int32.Parse(str);
}
reader.Close();
this.zielPos.x = data[0];
this.zielPos.y = data[1];
this.zielPos.h = data[2];
streckeProTakt = data[3];
flughöhe = data[4];
steighöheProTakt = data[5];
sinkhöheProTakt = data[6];
//"typ" aus data[7] initialisieren
Array typen = Enum.GetValues(typeof(Airbus));
this.typ = (Airbus)typen.GetValue(data[7]);
sitzplätze = data[8];
Console.WriteLine("Flug {0} vom Typ {1} mit {2} Plätzen initialisiert.", kennung, typ, sitzplätze);
steigt = true;
Console.WriteLine();
return true;
}
}
class Program
{
public static TransponderDel transponder;
// Wiederholungsaufgabe 2.3
public delegate void FliegerRegisterDel();
public static FliegerRegisterDel fliegerRegister;
public static bool protokollieren = true;
public void ProgrammTaken()
{
Düsenflugzeug flieger1 = new Düsenflugzeug("LH 500", new Position(3500, 1400, 180));
Düsenflugzeug flieger2 = new Düsenflugzeug("LH 3000", new Position(3000, 2000, 100));
while (fliegerRegister != null)
{
fliegerRegister();
Console.WriteLine();
Thread.Sleep(1000);
}
}
static void Main(string[] args)
{
Program test = new Program();
test.ProgrammTaken();
Console.ReadLine();
}
}
}
Meine Aufgabe besteht darin für 2 Flieger (flieger1 und flieger2) die Flugkoordinaten in eine jeweils für den entsprechenden flieger gefertigte Datei zu schreiben. Also sprich eine Art "Blackbox" zu entwickeln.
Mit der Methode ProtokollErstellen() (welche ich für diesen zweck geschrieben habe) werden die Dateien erstellt und der Header der des Fluges (string headerContent) in die Datei geschrieben. Das funktioniert alles.
Das was nun NICHT funktioniert sind die fortlaufenden Koordinaten X,Y,H wobei das H für die Höhe steht.
in der Datei Sollte das dann SO aussehehn:
Flug LH (Typ A300) startet an Position 1000,200,200 mit Zielposition 300,44,4.
1000 201 399
1000 342 300
200 233 234
Dabei muss beachtet werden dass X,Y, und H int werte sein müssen.
ich habe es mit einer whileschleife versucht
while(fliegerRegister 1= null)
{
writer.write();
}
bekomme aber nur
"ESA_Project.Program.FliegerRegisterDel" in die Datei geschrieben.
was mache ich hier falsch?
vielen dank im Vorraus
Hallo an alle,
Gegeben sei das folgende Byte-Array:
byte[] array = {32, 32, 67, 67, 32, 32, 32, 35, 32, 35, 32,
32, 67, 32, 32, 67, 32, 32, 35, 32, 35, 32,
67, 32, 32, 32, 32, 32, 35, 35, 35, 35, 35,
67, 32, 32, 32, 32, 32, 32, 35, 32, 35, 32,
67, 32, 32, 32, 32, 32, 35, 35, 35, 35, 35,
32, 67, 32, 32, 67, 32, 32, 35, 32, 35, 32,
32, 32, 67, 67, 32, 32, 32, 35, 32, 35, 32 };
Nun soll ich dieses array in eine Textdatei speicher (klappt einwandfrei) und mit einer anderen Methode in einer Console ausgeben. Der Clou ist nun das ich nur 7 Zeilen mit je max 11 zeichen an platz verwenden soll.
Meine derzeitige lösung:
public void ESAOut(string pfad)
{
FileStream reader = File.Open(pfad, FileMode.Open);
byte[] array = new byte[reader.Length];
reader.Read(array, 0, (int)array.Length);
for (int i = 0; i < array.Length; i++)
{
Console.Write("{0} {0} {0} {0} {0} {0} {0} {0} {0} {0} {0} \n", (byte)array[i]);
}
reader.Close();
Console.ReadLine();
}
ist nicht so die lösung.
wer kann mir helfen. ich hänge da seit 3 Wochen dran.
Hallo alle zusammen,
ich Studiere gerade bei der ILS Fachinformatik und habe eine "eigentlich" einfache Aufgabe welche ich nicht lösen kann. Ich soll eine Datei erstellen.
class Program
{
public void Datei(string path, byte[] array)
{
using (FileStream stream = new FileStream(path, FileMode.Create))
{
stream.Write(array, 0, array.Length);
stream.Close();
}
}
static void Main(string[] args)
{
Program test = new Program();
string path = @"C:\testordner\datei.txt";
byte[] array = { 68, 97, 116, 101, 105 };
test.Datei(path, array);
}
Die Datei "datei.txt" wird jedoch nicht erstellt. Ich habe meinen Fernlehrer hierzu gefragt und der meinte das der Code korrekt ist. Ändert aber nichts an der sachlage.
Das Programm ist eine Consolenanwendung (mit Visual Studio geschrieben) und wird mit:
Das Programm "[6980] ESA.exe: Programmablaufverfolgung" wurde mit Code 0 (0x0) beendet.
Das Programm "[6980] ESA.exe" wurde mit Code 0 (0x0) beendet.
Auch eine Ausnahme bleibt aus. Selbst wenn ich
try
{
using (stream = new FileStream(path, FileMode.Create))
{
stream.Write(array, 0, array.Length);
stream.Close();
}
}
catch(Exception e)
{
Console.WriteLine("Error");
}
schreibe wird keine Ausnahme ausgelöst. Bei Microsoft habe ich den Hinweis mit dem FileAccess gefunden und den Code wie folgt umgestellt
using (FileStream stream = new FileStream(path, FileMode.Create, FileAcces access))
Aber auch das blieb erfolglos. Was mache ich hier falsch?