• Du befindest Dich hier:
• Community
• »
• Mitglieder
• »
• pollito
• »
• Beiträge von pollito

Zunächst sorry, dass ich etwas abschweife, aber ich denke, das kann für den einen oder anderen interessant sein.

Ich habe weiter geforscht und bin zur Erkenntnis gekommen, dass mein Provider all-inkl den Zugriff auf Datenbanken über einen SSH-Tunnel unterbindet. Zwar ist SSH möglich, nicht jedoch einen SSH-Tunnel einzurichten. Daher habe ich den Support kontaktiert, der – wie immer – sehr schnell antwortete:

UPDATE

Ich habe das gleiche Testprogramm aber mit anderen Verbindungs- und Zugangsdaten ausgeführt. Im Wesentlichen handelt es sich um andere Internet-Provider. Hier stelle ich fest, dass die anderen Provider keine Probleme machen und alles läuft, wie es sein sollte. Dabei ist mir etwas aufgefallen: Den Fehler macht nicht die Methode ForwardedPortLocal, wie ich fälschlicherweise vermutete. Wenn ich nach der Portweiterleitung anhalte, sehe ich in allen Fällen folgendes:

TCP    127.0.0.1:3306         0.0.0.0:0                ABHÖREN         42608

Proto    Lokale Adresse         Remoteadresse          Status           PID

  TCP    127.0.0.1:3306         0.0.0.0:0              ABHÖREN         51156
 [sshtest2.exe]
  TCP    127.0.0.1:3306         127.0.0.1:62024        HERGESTELLT     51156
 [sshtest2.exe]
  TCP    127.0.0.1:62024        127.0.0.1:3306         HERGESTELLT     51156
 [sshtest2.exe]

Doch, so funktioniert SSH.NET. Nachdem man eine SSH-Verbindung hergestellt hat, kann man die Portweiterleitung einrichten. Die Methode

new ForwardedPortLocal("127.0.0.1", 3306, "127.0.0.1", 3306);

-	portfwd	{Renci.SshNet.ForwardedPortLocal}	Renci.SshNet.ForwardedPortLocal
		BoundHost		"127.0.0.1"		string
		BoundPort		3306			uint
		Host			"127.0.0.1t"	string
		IsStarted		true			bool
		Port			3306			uint

Danke! Ich hatte in meiner unendlichen Verzweiflung vergessen, zu erzählen, dass ich dies schon alles durchgetestet habe.

Hallo,

ich habe mehrere Anwendungen, die SSH.NET (SSH.NET) nutzen. Hierbei handelt es sich bisher immer um Datenbankzugriffe auf MySQL- bzw. MariaDB-Datenbanken. Nun muss ich eine weitere Anwendung erstellen, die ebenfalls auf eine MariaDB-Datenbank zugreift – das treibt mich aber zum Wahnsinn.

Die SSH-Verbindung wird dabei erfolgreich hergestellt und ich kann beliebige Shell-Befehle absetzen. So weit, so gut. Allerdings möchte ich auf die Datenbank zugreifen, so dass ich eine lokale Portweiterleitung einrichte – diese scheint jedoch nicht zu wirken, obwohl im Debugger alles richtig erscheint.

Nun ein wenig Code, bevor ich weiter erkläre:

			ConnectionInfo ConnNfo = new ConnectionInfo("domäne.tld", 22, "ssh-user",
				new AuthenticationMethod[]
				{
					new PrivateKeyAuthenticationMethod("ssh-user", new PrivateKeyFile[]
						{
							new PrivateKeyFile(@"C:\Daten\Visual Studio\Projects\Z-Tests\sshtest2\.ssh\private.key", "PassPhrase")
						}
					),
				}
			);

			using var sshclient = new SshClient(ConnNfo);

			sshclient.Connect();

			var portfwd = new ForwardedPortLocal(IPAddress.Loopback.ToString(), 3306, "localhost", 3306);
			sshclient.AddForwardedPort(portfwd);
			portfwd.Start();

			using MySqlConnection MySqlCon = new ("server=127.0.0.1; user id=benutzer; password=kennwort; database=datenbank; Allow Zero Datetime=True; persistsecurityinfo=False");

			/*
			 * Unbehandelte Ausnahme
			 * 
			 * MySql.Data.MySqlClient.MySqlException: "Reading from the stream has failed."
			 * 
			 * Innere Ausnahme
			 * EndOfStreamException: Attempted to read past the end of the stream.
			 * 
			 */
			MySqlCon.Open();			// <--- Ausnahme

			MySqlCon.Close();
			sshclient.Disconnect();

-	portfwd	{Renci.SshNet.ForwardedPortLocal}	Renci.SshNet.ForwardedPortLocal
		BoundHost		"127.0.0.1"		string
		BoundPort		3306			uint
		Host			"localhost"		string
		IsStarted		true			bool
		Port			3306			uint

Console.WriteLine(sshclient.CreateCommand("ls -lah ~/.ssh").Execute());

netstat -bano -p TCP

Aktive Verbindungen

  Proto  Lokale Adresse         Remoteadresse          Status           PID

  TCP    10.0.70.5:59619        192.168.70.204:49172   WARTEND         0
  TCP    10.0.70.5:59620        192.168.70.204:49172   WARTEND         0
  TCP    10.0.70.5:59773        192.168.70.204:135     HERGESTELLT     5732
 [spoolsv.exe]
  TCP    10.0.70.5:59774        192.168.70.204:135     HERGESTELLT     5732
 [spoolsv.exe]
  TCP    10.0.70.5:59775        192.168.70.204:135     HERGESTELLT     5732
 [spoolsv.exe]
  TCP    10.0.70.5:59776        192.168.70.204:49172   SYN_GESENDET    5732
 [spoolsv.exe]
  TCP    10.0.70.5:59777        192.168.70.204:49172   HERGESTELLT     5732
 [spoolsv.exe]
  TCP    127.0.0.1:3306         0.0.0.0:0              ABHÖREN         42608
 [sshtest2.exe]
  TCP    127.0.0.1:8884         0.0.0.0:0              ABHÖREN         4
 Es konnten keine Besitzerinformationen abgerufen werden.
  TCP    127.0.0.1:9395         127.0.0.1:56791        HERGESTELLT     6704
 

TCP    127.0.0.1:3306         0.0.0.0:0                ABHÖREN         42608

TCP    127.0.0.1:3306         127.0.0.1:3306           ABHÖREN         42608

Ach so, der Wert entspricht zwar einem int, der Datentyp ist jedoch ein anderer (hier RV). Einleuchtend – da habe ich die MS-Hilfe zu wörtlich genommen bzw. missverstanden.

Vielen Dank für die rasante Hilfe!

Einen schönen Tag und bis zur nächsten Frage.

René

Hallo an alle,

ich habe wieder einmal ein Verständnisproblem – diesmal bei der Verwendung von enum. Wie Microsoft unter "Enumerationstypen: C#-Referenz" beschreibt, sind die einzelnen Werte, sofern man nichts anders angibt, standradmäßig int – in diesem Fall genau das, was ich brauche.

Nun füge ich nachstehend ein kurzes Testprogramm bei, welches meine Frage veranschaulicht.

• Ich definiere ein enum RV mit vordefinierten int-Werten.
• Im nachfolgendem Dictionary<int, string> RetVal nutze ich die enum-Werte als Key.

namespace enum_dic
{
	internal class Program
	{
		static void Main(string[] args)
		{
			foreach (var rv in Constants.RetVal)
			{
				Console.WriteLine($"{rv.Key,4}\t{rv.Value}");
			}

			Console.ReadLine();
		}
	}


	internal static class Constants
	{
		internal enum RV
		{
			Success						=    0,
			WrongParameterNumber		=   -1,
			OrderNotFound				=   -2,
			CannotWriteLogFile			=   -3,
			ErrorInCommandLine			=  -50,
			DataViewNotCreated			=  -60,
			NotDataFound				=  -61,
			MoreThanOneArticle			=  -70,
			ArticleNotFoundInPartList	=  -72,
			ErrorWhileQueryingDatabase2	=  -96,
			ErrorWhileQueryingDatabase	=  -97,
			WorkerMayBeStartedOnlyOnce	=  -98,
			WorkerCouldNotBeSetup		=  -99,
			UntreatedException			= -100
		}

		internal static readonly Dictionary<int, string> RetVal = new()
		{
			{ (int) RV.Success,                       "Erfolgreiche Ausführung" },
			{ (int) RV.WrongParameterNumber,          "Falsche Parameterzahl" },
			{ (int) RV.OrderNotFound,                 "Auftrag nicht auffindbar" },
			{ (int) RV.CannotWriteLogFile,            "Zugriff auf Logdatei nicht möglich" },
			{ (int) RV.ErrorInCommandLine,            "Fehler beim Prüfen der Kommandozeilenparameter" },
			{ (int) RV.DataViewNotCreated,            "Die DataView konnte nicht erstellt werden." },
			{ (int) RV.NotDataFound,                  "Daten konnten nicht gefunden werden." },
			{ (int) RV.MoreThanOneArticle,            "Mehr als ein E11- bzw. E33-Artikel in der Stückliste gefunden." },
			{ (int) RV.ArticleNotFoundInPartList,     "Der gesuchte Artikel wurde in der Stückliste nicht gefunden." },
			{ (int) RV.ErrorWhileQueryingDatabase2,   "Fehler beim Abfragen der Datenbank. Spalten bzw. Zeilen dürfen nicht Null sein." },
			{ (int) RV.ErrorWhileQueryingDatabase,    "Fehler beim Abfragen der Datenbank" },
			{ (int) RV.WorkerMayBeStartedOnlyOnce,    "Der Worker darf nur einmal gestartet werden." },
			{ (int) RV.WorkerCouldNotBeSetup,         "Der Worker konnte nicht eingerichtet werden." },
			{ (int) RV.UntreatedException,            "Unbehandelte Ausnahme" }
		};
	}
}

Danke, dann bin ich in guter Gesellschaft und nicht alleine.

Eine erfolgreiche Arbeitswoche!

LG

René

Hallo Th69,

in jeder erdenklichen Kombination werden beide Warnungen ausgegeben. Wie gesagt, an dieser Stelle nicht schlimm, denn ich weiß, dass alles OK ist. Daher habe ich nur für die betroffene Zeile diese Compilerwarnungen deaktiviert:

#pragma warning disable CS8601, CS8602     // Mögliche Nullverweiszuweisung bzw. Dereferenzierung eines möglichen Nullverweises
			ds.Tables["Artikel"].PrimaryKey	= new DataColumn[1] { ArtikelColumns["NUMMER"] };
#pragma warning restore CS8602, CS8601

Hallo nochmals,

ich stelle fest, dass nach jedem Laden eines Projektes die Häkchen in der Spalte "Erstellen" (Erstellen | Batch erstellen" bzw. Alt+E+C einfach wieder weg sind. Das war aber mal anders und ich weiß nicht, ob man das dauerhaft beeinflussen kann und wenn, wo?

Kann das jemand bestätigen oder ist es ein lokales, nur bei mir erscheinendes Problem?

Hier die Infos über meine Installation:

Microsoft Visual Studio Professional 2022
Version 17.4.2
VisualStudio.17.Release/17.4.2+33122.133
Microsoft .NET Framework
Version 4.8.09032
Installierte Version: Professional

Hallo,

ich habe folgende Frage. Visual Studio 2022 meckert in der unten stehenden Zeile gleich zwei Male:

ds.Tables["Artikel"].PrimaryKey = new DataColumn[1] { ArtikelColumns["NUMMER"] };

#pragma warning disable CS8601, CS8602    // Mögliche Nullverweiszuweisung bzw. Dereferenzierung eines möglichen Nullverweises
ds.Tables["Artikel"].PrimaryKey = new DataColumn[1] { ArtikelColumns["NUMMER"] };
#pragma warning restore CS8602, CS8601

if (ds != null && ds.Tables != null || ds?.Tables?["Artikel"] != null && ArtikelColumns["NUMMER"] != null)
{
	ds.Tables["Artikel"].PrimaryKey = new DataColumn[1] { ArtikelColumns["NUMMER"] };
}

Es hat sich aber nichts geändert.

Versagt hier IntelliSense oder mache ich grundsätzlich was falsch und ich merke es nur nicht?

Liebe Grüße

René

OK, Problem gelöst. Ich habe mich von der Fehlermeldung in die Irre treiben lassen und an der falschen Stelle nach der Fehlerursache gesucht. Nun bin ich Schritt für Schritt systematisch vorgegangen und siehe da, ganz am Anfang schmiert der Dienst ab, ohne etwas zu machen. Der Fehler lag am "displayname" des Dienstes – dieser darf maximal 80 Zeichen lang sein, während ich 110 Zeichen verwendete. Das wusste ich nicht und die Fehlermeldung sagte auch was ganz anderes.

Lieben Dank für eure Hilfe! Das Wochenende ist gerettet!

LG

René

In meiner Verzweiflung habe ich den Wert in der Registry "stark" erhöht:

Computer\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control
ServicesPipeTimeout (REG_DWORD): 0x180000

Danke nochmals. Ich werde jetzt systematisch schrittweise vorgehen.

Die beiden Einträge bekomme ich, wenn ich den Dienst starten will:

Protokollname: System
Quelle:        Service Control Manager
Datum:         09.09.2022 10:35:40
Ereignis-ID:   7000
Aufgabenkategorie:Keine
Ebene:         Fehler
Schlüsselwörter:Klassisch
Benutzer:      Nicht zutreffend
Computer:      RKK-XPS.isential.local
Beschreibung:
Der Dienst "WooComMesserschmidt" wurde aufgrund folgenden Fehlers nicht gestartet: 
Der Dienst antwortete nicht rechtzeitig auf die Start- oder Steuerungsanforderung.

Protokollname: System
Quelle:        Service Control Manager
Datum:         09.09.2022 10:35:40
Ereignis-ID:   7009
Aufgabenkategorie:Keine
Ebene:         Fehler
Schlüsselwörter:Klassisch
Benutzer:      Nicht zutreffend
Computer:      RKK-XPS.isential.local
Beschreibung:
Das Zeitlimit (1572864 ms) wurde beim Verbindungsversuch mit dem Dienst WooComMesserschmidt erreicht.

Danke. Was mich aber dabei sehr wundert, ist die Tatsache, dass der Fehler ziemlich schnell Auftritt – keine 30, sondern maximal zwei Sekunden.

Hallo,

heute melde ich mich wieder einmal mit einem Problem, das ich trotz Suche nicht gelöst bekomme.

Ich habe einen Windows-Dienst für .Net 6 programmiert, der von BackgroundService erbt:

namespace WooComMesserschmidt
{
	internal class Worker : BackgroundService
	{
		private	readonly HttpClient						Client			= new()
		private	string									BaseAddress		= string.Empty;
		private	readonly IConfiguration					Configuration;
		private	string									ConfigFile		= string.Empty;
		private readonly Dictionary<string, dynamic?>	_ConfigPar;
		internal static	 Dictionary<string, string>		ConfigPar		= new();
		private readonly ILogger<Worker>				_logger;

		public struct LogInfo
		{
			public ILogger<Worker>? Logger;
			public string?			LogFile;

			public LogInfo(ILogger<Worker>? logger, string logfile)
			{
				Logger	= logger;
				LogFile	= logfile;
			}
		}

		public static LogInfo logInfo;

		public Worker(ILogger<Worker> logger, IConfiguration configuration, Dictionary<string, dynamic?> configpar)
		{
			Configuration	= configuration;
			_ConfigPar      = configpar;
			_logger         = logger;

			Init();
		}
...

		protected override async Task ExecuteAsync(CancellationToken stoppingToken)
		{
			// Abfrageintervall in Millisekunden
			if (int.TryParse(ConfigPar[cpQueryInterval], out int QueryInterval) == false)
			{
				QueryInterval = QueryIntervalStd;
				Log.LogInformation(logInfo, $"Abfrageintervall konnte nicht ermittelt werden. Es wird daher der Standardwert von {QueryInterval} Millisekunden verwendet. Prüfen Sie die Angaben in der Parameterdatei.");
			}

			Log.LogInformation(logInfo, $"{Process.GetCurrentProcess().ProcessName} gestartet.");
			Log.LogInformation(logInfo, $"Worker arbeitet mit Abfrageintervall von {QueryInterval} Millisekunden.");

			while (stoppingToken.IsCancellationRequested == false)
			{
				// Neue Bestellungen verarbeiten.
				await ProcessNewOrders();

				// Artikel aktualisieren – zurzeit nur den Preis aktualisieren.
				await UpdateProducts();

				// DHL-Dateien verarbeiten.
				Dhl_Polling();

				// Nun legen wir uns aufs Ohr für ein Weilchen.
				await Task.Delay(QueryInterval, stoppingToken);
			}
		}
...

		private static async Task<int> Main(string[] args)
		{
			try
			{
				IHost host = Host.CreateDefaultBuilder(args)
					.UseWindowsService(options =>
					{
						options.ServiceName = ServiceName;
					})
					.ConfigureServices(services =>
					{
						services.AddSingleton<Dictionary<string, dynamic?>> (_ConfigPar);
						
						services.AddHostedService<Worker>();
					})
					.Build();

				await host.RunAsync();

				Log.LogInformation((LogInfo)_ConfigPar[cpLogInfo], $"{Process.GetCurrentProcess().ProcessName} beendet.");

				if (Debugger.IsAttached == true)
				{
					Console.ReadLine();
				}
			}
			catch (Exception ex)
			{
				Console.WriteLine($"{ex}{Environment.NewLine}{Environment.NewLine}");
...

Natürlich nicht. Das sind von der PayPal-Sandbox zur Verfügung gestellten Daten

Lieben Dank, das hat mir weitergeholfen.

Im ersten Fall reicht es ein simples ToString() vollkommen aus:

var result = meta.Value.ToString();

Zahlungsanweisung? za = JsonSerializer.Deserialize<Zahlungsanweisung>(meta.Value.ToString());

Zahlungsanweisung
    Transaktionsnummer    "5GB5061965299422G"             string
    Zahlungsart           "PAY_UPON_INVOICE"              string
    Zahlungsinformation
        BIC                   "DEUTDEDBPAL"               string
        Bank                  "Deutsche Bank"             string
        IBAN                  "DE63120700888000584157"    string
        Kontoinhaber          "PayPal Europe"             string

Hallo,

ich möchte mit .NET 6 aus einem E-Shop die Zahlungsanweisung über dessen RESR-API ermitteln (dafür nutze ich "System.Text.Json" und "System.Text.Json.Serialization)". Es funktioniert auch alles, aber an einer Stelle drehe ich mich im Kreis. Hier ein kleiner Ausschnitt aus den JSON-Daten (E-Shop-Bestellung):

   "meta_data": [
        {
            "id": 31477,
            "key": "_shipping_address_type",
            "value": ""
        },
        {
            "id": 31479,
            "key": "_additional_costs_include_tax",
            "value": "yes"
        },
        {
            "id": 31480,
            "key": "_shipping_dhl_address_type",
            "value": "regular"
        },
        {
            "id": 31481,
            "key": "_gzd_version",
            "value": "3.9.8"
        },
        {
            "id": 31482,
            "key": "_new_order_email_sent",
            "value": "true"
        },
        {
            "id": 31484,
            "key": "is_vat_exempt",
            "value": "no"
        },
        {
            "id": 31487,
            "key": "reference_number",
            "value": "5GB5061965299422G"
        },
        {
            "id": 31488,
            "key": "instruction_type",
            "value": "PAY_UPON_INVOICE"
        },
        {
            "id": 31489,
            "key": "payment_due_date",
            "value": "2022-09-17"
        },
        {
            "id": 31490,
            "key": "bank_name",
            "value": "Deutsche Bank"
        },
        {
            "id": 31491,
            "key": "account_holder_name",
            "value": "PayPal Europe"
        },
        {
            "id": 31492,
            "key": "international_bank_account_number",
            "value": "DE63120700888000584157"
        },
        {
            "id": 31493,
            "key": "bank_identifier_code",
            "value": "DEUTDEDBPAL"
        },
        {
            "id": 31494,
            "key": "_payment_instruction_result",
            "value": {
                "reference_number": "5GB5061965299422G",
                "instruction_type": "PAY_UPON_INVOICE",
                "recipient_banking_instruction": {
                    "bank_name": "Deutsche Bank",
                    "account_holder_name": "PayPal Europe",
                    "international_bank_account_number": "DE63120700888000584157",
                    "bank_identifier_code": "DEUTDEDBPAL"
                }
            }
        },
usw.

internal class Orders
{
	...
	/// <summary>
	/// Metadaten wie u. v. a. Zahlungsinformation
	/// </summary>
	[JsonPropertyName("meta_data")]
	public List<MetaData> Metadaten { get; set; } = new();
	...
}

public class MetaData
{
	/// <summary>
	/// ID
	/// </summary>
	[JsonPropertyName("id")]
	public int Id { get; set; }

	/// <summary>
	/// Key
	/// </summary>
	[JsonPropertyName("key")]
	public string Key get; set; } = string.Empty;

	/// <summary>
	/// Value
	/// </summary>
	[JsonPropertyName("value")]
	public object Value { get; set; }
}

        {
            "id": 31494,
            "key": "_payment_instruction_result",
            "value": {
                "reference_number": "5GB5061965299422G",
                "instruction_type": "PAY_UPON_INVOICE",
                "recipient_banking_instruction": {
                    "bank_name": "Deutsche Bank",
                    "account_holder_name": "PayPal Europe",
                    "international_bank_account_number": "DE63120700888000584157",
                    "bank_identifier_code": "DEUTDEDBPAL"
                }
            }
        },

public class Zahlungsanweisung
{
	/// <summary>
	/// Transaktionsnummer
	/// </summary>
	[JsonPropertyName("reference_number")]
	public string Transaktionsnummer { get; set; } = string.Empty;

	/// <summary>
	/// Zahlungsart
	/// </summary>
	[JsonPropertyName("instruction_type")]
	public string Zahlungsart { get; set; } = string.Empty;

	/// <summary>
	/// Zahlungsinformation
	/// </summary>
	[JsonPropertyName("recipient_banking_instruction")]
	public Zahlungsinformation Zahlungsinformation { get; set; } = new();
}

public class Zahlungsinformation
{
	[JsonPropertyName("bank_name")]
	public string Bank { get; set; } = string.Empty;

	[JsonPropertyName("account_holder_name")]
	public string Kontoinhaber { get; set; } = string.Empty;

	[JsonPropertyName("international_bank_account_number")]
	public string IBAN { get; set; } = string.Empty;

	[JsonPropertyName("bank_identifier_code")]
	public string BIC { get; set; } = string.Empty;
}

Id		31479							int
Key		"_additional_costs_include_tax"	string
Value	ValueKind = String : "yes"		object {System.Text.Json.JsonElement}

Id		31494							int
Key		"_payment_instruction_result"	string
Value	ValueKind = Object : "{"reference_number":"5GB5061965299422G","instruction_type":"PAY_UPON_INVOICE","recipient_banking_instruction":{"bank_name":"Deutsche Bank","account_holder_name":"PayPal Europe","international_bank_account_number":"DE63120700888000584157","bank_identifier_code":"DEUTDEDBPAL"}}"	object {System.Text.Json.JsonElement}

Danke euch beiden!

Der Ansatz mit AntMe finde ich sehr interessant. Ich denke, wenn das gut gemacht ist, dass es für Kinder besser als ein dicker Schinken ist. Wenn der Junge nach einer gewissen Zeit weiterhin motiviert bleibt, kann er zu einem Buch wie z. B. Schrödinger greifen. Auch diesen Ansatz finde ich interessant, allerdings ist das Buch mittlerweile relativ alt – vielleicht kommt aber eine neue Auflage.

Und sollte mein Junge dabei bleiben, hat er mich immer noch, wenn er Fragen hat...

Nochmals vielen Dank und liebe Grüße

René

Jetzt habe ich eine vielleicht merkwürdige Frage. Mein ältestes Enkelkind ist 9 Jahre alt – es wird erst zu Weihnachten 10. Es scheint so zu sein, dass es ziemlich technikbegabt ist. Sehr gute Noten in Mathe, Deutsch, Sport usw. Dagegen Musik, Kunst o. ä. nur soviel, wie unbedingt nötig – das ist nicht seins.

Er hat mich vor einigen Wochen überrascht, indem er mir eigene (einfache) Spieleerweiterungen von Roblox gezeigt hat. Diese programmiert er in der Skriptsprache "Lua", von der ich bis dato nie gehört hatte. Er hat sich sogar ein Programmierbuch bestellt (ein dicker Schinken), um tiefer einzusteigen.

Nun erzählte er mir gestern, dass er lieber eine "richtige" Programmiersprache erlernen wollte. Er hätte schon Visual Studio heruntergeladen und installiert und würde gerne C# lernen. Da war ich wieder baff! Er ist 9 und Kinder in diesem Alter sollten was anderes an der frischen Luft machen. Dann zeigte er mir einige Bücher, die er sich ausgeguckt hatte und fragte mich, welches ich empfehlen würde. Keine Ahnung!

Gibt es überhaupt etwas für Kinder/Jugendliche in diesem Bereich (Bücher, Bibliotheken, Spiele), was ihnen die C#-Sprache etwas sanfter näherbringt? Wenn er einen wirklich dicken C#-Schinken in die Hände nimmt, brechen ihm die Handgelenke.

Ich bin damit etwas überfordert und ich weiß auch nicht, ob dies für einen Neujährigen OK ist. Das kommt allerdings alleine von ihm aus und wie es scheint, hat er Spaß daran.

Lieben Dank und viele Grüße

René

Manchmal sucht man am Suchbegriff vorbei... Vielen Dank!

Ich kenne mich mit PDF nahezu Null aus. Muss die gewünschte Ziel-Schriftart in das Dokument eingebettet sein, um eine vorhandene durch die Ziel-Schriftart zu ersetzen, oder reicht es, wenn diese Schrift in Windows vorhanden ist?

Nochmals vielen Dank für deine Tipps und ein schönes Wochenende.

LG

René

Hallo,

ich habe wieder einmal eine Frage – diesmal bezüglich PDF.

Ich bekomme fertige PDF-Dateien. Diese sind relativ einfach gestrickt, denn sie stammen aus einem Programm, welches PCL-Dateien erstellt, die nur Text und einige Formatierungen (Fett, Kursiv, Unterstrichen usw.) enthalten. Die PCL-Dateien werden mit Hilfe eines anderen Programms (VeryPDF PCL Converter, ältere Version 1.5) in PDF umgewandelt.

Die PDF-Dateien bleiben durchsuchbar, also der Text wird nicht in Grafik umgewandelt.

Jetzt habe ich das Problem, dass ich erst hier ansetzen kann: Ich bekomme eine PDF-Datei und sollte einigen Texten eine andere Schriftart verpassen, die in das Dokument nicht eingebettet ist (sonst bräuchte man das nicht zu machen). Spezifisch geht es darum, zunächst den Text zu erkennen und danach diesem eine Barcodeschriftart zu verpassen.

Nun meine Frage: Gibt es bereits Werkzeuge dafür? Wie geht man damit am besten um?

Ich möchte keine fertige Lösung sondern Tipps, wie man dieses Problem sinnvoll angehen kann.

Danke und LG

René