Für WinForms Projekte (das glaube ich aus den verwendeten Klassen heraus lesen zu können) wird die Lokalisierung in der Regel über Ressourcen realisiert. Das ist eine auch vom WinForms-Designer unterstützte Variante. Lokalisierung bedeutet i.d.R. ja nicht nur das anpassen der Strings sondern oft auch eine Anpassung der Größen und Positionen einzelner Controls.
Wenn Du Deinen Weg weiterverfolgen möchtest, solltest Du dich auch mal mit der Schnittstelle IExtenderProvider auseinandersetzen und Dir Extension-Methoden genauer anschauen. Wie schon geschrieben ist das erstellen je einer eigenen Klasse je Control nicht de sinnvollste Weg solche Dinge umzusetzen.
Da hat Abt recht - meine Erfahrungen stammen noch aus 2019 (da hab ich das zum letzten mal selbst genutzt). Da war es noch möglich ohne ein Zertifikat zu veröffentlichen und die Anwendung wurde vom Microsoft selbst signiert. Seit Mai 2023 ist das wohl anders. Das hier habe ich dazu gefunden:
On June 16, 2022 we announced an update to Store policy. Win32 apps are required to be digitally signed, with a code signing certificate that chains up to a certificate issued by a Certificate Authority (CA) that is part of the Microsoft Trusted Root Program. New app submissions will not be allowed without an appropriate signature after May 1, 2023. Existing apps must be updated to include a digital signature per this policy before January 15, 2024.
Previously, all Microsoft Store apps (native UWPs for example) were hosted and signed by the Microsoft Store and received a Microsoft signature. With the change to our policy enabling Win32 apps to be listed in the Microsoft Store, and the removal of the waitlist for submitting Win32s, the new policy requires those apps to be digitally signed, and ensures all apps that customers acquire and download from the Microsoft Store have a trusted digital certificate.
Als Alternative zur Zertifizierung könntest Du Deine Anwendung auch im Windows-AppStore anbieten und dann von Deiner Website auf den Eintrag im Store verlinken. Damit entfällt für dich die Notwendigkeit, das Installationsprogramm selbst signieren zu müssen...
Veröffentlichen von Windows-Apps - Windows apps | Microsoft Learn
Wie kommst Du darauf, dass sich für einen Public Folder 'DefaultItemType' ändert, nur weil Du für den Ordner 'E-Mail-aktivierst'?
Die 'E-Mail-Aktivierung bedeutet doch IMHO nur, dass der Ordner unter eigener E-Mail-Adresse erreichbar ist und ggf. als Absender verwendet werden kann.
Ich verstehe nicht, warum Outlook den Ordner falsch behandelt (ich kann nur Postings erstellen und keine Mails verschicken).
Ich verstehe nicht ganz, was Du hier versuchst. Natürlich kannst Du im Ordner nur 'Postings' erstellen. Der Ordner selbst ist ja kein Postfach, was tatsächlich E-Mails verschicken kann. Du kannst nur aus deinem Postfach heraus E-Mails im Namen des Ordners verschicken - der Empfänger sieht dann den Ordner als 'Absender' und Antworten gehen in diesen Ordner.
BTW: Ich würde für solche Dinge immer nur EWS verwenden. Man tut sich deutlich leichter, hat mehr Möglichkeiten und ist nicht auf ein installiertes Outlook angewiesen.
Wenn Du, wie von mir empfohlen einen BreakPoint in fNummerComboBox_SelectedIndexChanged und einen in Vertrageinzel_Load setzt, wirst Du bemerken, dass fNummerComboBox_SelectedIndexChanged VOR Vertrageinzel_Load ausgeführt wird. Das heisst, Deine fNummerComboBox löst das Ereignis SelectedIndexChanged bereits aus, bevor dein Form das OnLoad-Ereignis auslöst und damit Vertrageinzel_Load ausführt.
Das liegt daran, dass Du höchstwahrscheinlich bereits im Designer für fNummerComboBox einen Wert setzt. Das setzen dieses Wertes wiederum führt dazu, dass fNummerComboBox_SelectedIndexChanged aufgerufen wird.
Der Ablauf ist also so:
- VertragEinzel() // Constructor
- InitializeComponent() // ausführen des vom Designer generierten Codes...
- fNummmerCombobox.SelectedIndex = 1 // in VertragEinzel.designer.cs - 1 hier mal nur als Beispiel
- fNummerComboBox_SelectedIndexChanged(..) // Aufruf der Ereignis-Methode
- Vertrageinzel_Load(...) // Aufruf der Ereignismethode durch das OnLoad-Event das quasi am Ende von InitializeComponent ausgelöst wird...
Du siehts also, dass Du das SelectedIndexChanged-Ereignis bis NACH der Ausführung von Vertrageinzel_Load ignorieren musst.
Hier findest Du noch ein paar Informationen zur Reihenfolge der ausgelösten Events:
Reihenfolge der Ereignisse - Windows Forms .NET Framework | Microsoft Learn
Leider ist im gezeigten Code nicht ersichtlich, wo genau 'PreisBerechnen' aufgerufen wird und was genau 'GetPreisProTag' macht. Ohne die Information wird Dir niemand helfen können.
Ansonsten: Nutze den Debugger um Schritt für Schritt den Code durchzugehen. Dann wirst Du schon sehen, dass Du 'PreisBerechnen' offenbar aufrufst, bevor die Tabelle gefüllt wird. Kleiner Hinweis: fNummerComboBox_SelectedIndexChanged ist der Punkt, an dem Du das Debuggen beginnen solltest...
In der aktuellen Version von C# (12.0) kann man das z.B. so machen:
enum DX
{
DXLOCK,
HIGHDEF,
SCHNECKEN_POWER
}
// primärerer Constructor: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/primary-constructors
class RegisterEigenschaften(byte val,byte iFlag, string nameStr,DX regNr)
{ }
class DFx
{
// collection expression: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-12#collection-expressions
List<RegisterEigenschaften> DFlist= [
new(0,0,"Status", DX.DXLOCK ),
new(0,0,"AnalogValue", DX.HIGHDEF),
new(0,0,"PWM", DX.SCHNECKEN_POWER),
];
}
Für Desktop-Anwendungen gibt es außerhalb der Microsoft-Welt auch noch dies hier:
Noch Beta, sieht aber schon recht vielversprechend aus...
Wenn es auch was kosten darf... Schaust Du hier: MVVM Framework for WinForms (devexpress.com)
Nachdem Du ja nun schon weißt, was und warum alles nicht geht und hier mal bisschen was konstruktiveres... Bitte beachten, dass es durchaus Einschränkungen für die Funktion dieses Codes geben kann (virtuelle PCs etc.) - inwieweit das für dich nutzbar ist, musst Du selbst entscheiden - hängt auch davon ab, ob und wie Du die 'Umgebung' in der das genutzt werden soll unter 'Kontrolle' hast.
Wie kann ich per C# einen Rechner eindeutig identifizieren?
using System.Management;
using System.Net.NetworkInformation;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
namespace SystemInfo;
[SupportedOSPlatform("windows")]
internal class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello, World!");
SystemInfo ifo = new();
Console.WriteLine("CPU: "+ifo.IDCpu);
Console.WriteLine("MB: "+ifo.IDMotherboard);
Console.WriteLine("MAC: "+ifo.IDMac);
Console.WriteLine("DRIVE: "+ifo.IDSystemDrive);
Console.WriteLine(ifo.UniqueID);
Console.Read();
}
}
/// <summary>
/// Informationen zum Computer, auf dem die Anwendung gerade ausgeführt wird.
/// </summary>
public class SystemInfo
{
private string? _cpuid = null;
private string? _macid = null;
private string? _mbid = null;
private string? _systemserial = null;
private string? _uniqueid = null;
/// <summary>
/// ID des Prozessors des PCs
/// </summary>
[SupportedOSPlatform("windows")]
public string IDCpu
{
get
{
if (_cpuid != null) return _cpuid;
using ManagementClass mc = new("Win32_Processor");
using ManagementObjectCollection moc = mc.GetInstances();
foreach (var mo in moc)
{
_cpuid = mo.Properties["ProcessorId"].Value.ToString();
break;
}
_cpuid ??= "";
return _cpuid;
}
}
/// <summary>
/// ID des Motherboards des PCs
/// </summary>
[SupportedOSPlatform("windows")]
public string IDMotherboard
{
get
{
if (_mbid != null) return _mbid;
using ManagementClass mc = new("Win32_BaseBoard");
using ManagementObjectCollection moc = mc.GetInstances();
foreach (var mo in moc)
{
_mbid = mo.Properties["SerialNumber"].Value.ToString();
break;
}
_mbid ??= "";
return _mbid;
}
}
/// <summary>
/// MAC-Adresse der ersten Netzwerkkarte/der ersten Netzwerkschnittstelle des PCs
/// </summary>
public string IDMac
{
get
{
if (_macid != null) return _macid;
NetworkInterface[] interfaces = NetworkInterface.GetAllNetworkInterfaces();
foreach (NetworkInterface ni in interfaces)
{
if (ni.Supports(NetworkInterfaceComponent.IPv4) == false &&
ni.Supports(NetworkInterfaceComponent.IPv6) == false)
continue;
PhysicalAddress pa = ni.GetPhysicalAddress();
_macid = pa.ToString();
break;
}
_macid ??= "";
return _macid;
}
}
/// <summary>
/// Volume-ID des Systemlaufwerks
///
/// Seriennummer des Laufwerkes, auf dem sich das Betriebssystem befindet.
/// </summary>
public string IDSystemDrive
{
get
{
if (_systemserial != null) return _systemserial;
_systemserial = VolumeSerial(new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.System)));
return _systemserial;
}
}
/// <summary>
/// Liefert die VolumeInformationen zu einem Laufwerk
/// </summary>
/// <param name="PathName">Name des Pfades/Laufwerks</param>
/// <param name="VolumeNameBuffer"></param>
/// <param name="VolumeNameSize"></param>
/// <param name="VolumeSerialNumber"></param>
/// <param name="MaximumComponentLength"></param>
/// <param name="FileSystemFlags"></param>
/// <param name="FileSystemNameBuffer"></param>
/// <param name="FileSystemNameSize"></param>
/// <returns></returns>
[DllImport("kernel32.dll")]
public static extern long GetVolumeInformation(string PathName, StringBuilder VolumeNameBuffer, uint VolumeNameSize, ref uint VolumeSerialNumber, ref uint MaximumComponentLength, ref uint FileSystemFlags, StringBuilder FileSystemNameBuffer, uint FileSystemNameSize);
/// <summary>
/// Ermittelt die Seriennummer eines Laufwerkes als Hex-String
/// </summary>
/// <param name="dir">DirectoryInfo dessen VolumeSerial ermittelt werden soll</param>
/// <returns>Seriennummer als Hex-String (0x wenn ein Fehler auftrat)</returns>
public static string VolumeSerial(DirectoryInfo dir)
{
uint serNum = 0;
uint maxCompLen = 0;
string ret = "";
if (dir.FullName.Substring(1, 1) == ":")
{
StringBuilder VolLabel = new(256); // Label
uint VolFlags = new();
StringBuilder FSName = new(256); // File System Name
string drive = dir.FullName.Substring(0, 1) + ":\\";
GetVolumeInformation(drive, VolLabel, (uint)VolLabel.Capacity, ref serNum, ref maxCompLen, ref VolFlags, FSName, (uint)FSName.Capacity);
ret = Convert.ToString(serNum, 16);
}
else
{
throw new InvalidDataException($"{dir.FullName} is not located on a physical drive.");
}
return ret;
}
/// <summary>
/// eindeutige ID des Computers
///
/// Die eindeutige ID wird aus der ID der CPU,
/// der ID der Motherboards und der MAC-Adresse,
/// auf dem sich das Betriebssystem befindet gebildet
/// und dann verschlüsselt. Der so erstellte HashCode kann als eindeutige
/// ID des PCs verwendet.
///
/// Diese ID kann sich ändern, wenn das MotherBoard, die CPU, die Festplatte oder die Netzwerkkarte getauscht werden.
/// </summary>
[SupportedOSPlatform("windows")]
public string UniqueID
{
get
{
if (_uniqueid != null) return _uniqueid;
string ID = IDCpu + IDMac + IDMotherboard + IDSystemDrive;
using HMACSHA1 hmac = new();
hmac.Key = Encoding.ASCII.GetBytes(IDMotherboard);
hmac.ComputeHash(Encoding.ASCII.GetBytes(ID));
// Hash zu Hex-String konvertieren
StringBuilder sb = new();
foreach (var bt in hmac.Hash!)
sb.Append(bt.ToString("X2"));
_uniqueid = sb.ToString();
return _uniqueid;
}
}
}