public ModuleFileLoader(ISymbolLoader symbolLoader, IBinaryLoader binaryLoader,
IModuleSearchLogHolder moduleSearchLogHolder)
{
_symbolLoader = symbolLoader;
_binaryLoader = binaryLoader;
_moduleSearchLogHolder = moduleSearchLogHolder;
}
public void SetUp()
{
mockTask = Substitute.For <ICancelable>();
mockPlatformFileSpec = Substitute.For <SbFileSpec>();
mockPlatformFileSpec.GetDirectory().Returns(PLATFORM_DIRECTORY);
mockPlatformFileSpec.GetFilename().Returns(BINARY_FILENAME);
fakeModuleFileLoadRecorder = new FakeModuleFileLoadRecorder();
mockSymbolLoader = Substitute.For <ISymbolLoader>();
mockSymbolLoader
.LoadSymbolsAsync(Arg.Any <SbModule>(), Arg.Any <TextWriter>(), Arg.Any <bool>())
.Returns(Task.FromResult(false));
mockBinaryLoader = Substitute.For <IBinaryLoader>();
var anyModule = Arg.Any <SbModule>();
mockBinaryLoader
.LoadBinaryAsync(anyModule, Arg.Any <TextWriter>())
.Returns((anyModule, false));
mockModuleSearchLogHolder = new ModuleSearchLogHolder();
moduleFileLoader = new ModuleFileLoader(mockSymbolLoader, mockBinaryLoader,
mockModuleSearchLogHolder);
}
public void LinkDebugInfo(IMethodBody body)
{
var clrBody = body as IClrMethodBody;
if (clrBody == null)
{
return;
}
if (_initDebugInfo)
{
_initDebugInfo = false;
_symbolReader = CreateSymbolLoader();
}
if (_symbolReader == null)
{
return;
}
if (_symbolReader.LoadSymbols(clrBody))
{
clrBody.LocalVariables.UnifyAndNormalizeNames();
}
}
public static void CreateBuilder <T1>(ISymbolLoader loader = null) where T1 : NativeAPI
{
if (!_builders.ContainsKey(typeof(T1)) || loader != null)
{
_builders[typeof(T1)] = new NativeLibraryBuilder(Options)
.WithSymbolLoader(x => loader ?? x);
}
}
private static void PrintSymbols(AdsClient client)
{
SymbolLoaderSettings settings = new SymbolLoaderSettings(TwinCAT.SymbolsLoadMode.VirtualTree);
ISymbolLoader loader = SymbolLoaderFactory.Create(client, settings);
var symbols = loader.Symbols;
PrintSymbols(symbols);
}
public static T1 Load <T1, T2>(T2 baseApi, SearchPathContainer paths, ISymbolLoader loader)
where T1 : NativeExtension <T2> where T2 : NativeAPI
{
var builder = new NativeLibraryBuilder(Options).WithSymbolLoader(x => loader ?? x);
var extAttr = GetExtensionAttribute(typeof(T1));
return(baseApi.IsExtensionPresent(extAttr.Name)
? builder.ActivateClass <T1>((paths ?? baseApi.SearchPaths).GetLibraryName())
: null);
}
/// <inheritdoc />
protected NativeAPI
(
string path,
ImplementationOptions options,
ILibraryLoader libLoader = null,
ISymbolLoader symLoader = null
)
: base(path, options, libLoader, symLoader)
{
}
protected NativeLibraryBase
(
[CanBeNull] string path,
ImplementationOptions options,
[CanBeNull] ILibraryLoader libLoader = null,
[CanBeNull] ISymbolLoader symLoader = null
)
{
_libraryLoader = libLoader ?? PlatformLoaderBase.PlatformLoader;
_symbolLoader = symLoader ?? PlatformLoaderBase.PlatformLoader;
Options = options;
_libraryHandle = _libraryLoader.LoadLibrary(path);
}
/// <summary>
/// Constructor - establishes connection and creates symbol loader
/// </summary>
/// <param name="AmsNetId">ADS Client AMS Net Id "x.x.x.x.x.x:port" (127.0.0.1.1.1:851)</param>
public AdsConnection(string AmsNetId)
{
_client = new TcAdsClient();
// connect ADS client
_client.Connect(AmsAddress.Parse(AmsNetId));
if (_client.IsConnected)
{
// create symbol loader
_symbolLoader = SymbolLoaderFactory.Create(_client,
new SymbolLoaderSettings(SymbolsLoadMode.VirtualTree));
}
}
public void Dispose()
{
if (_symbolReader != null)
{
_symbolReader.Dispose();
_symbolReader = null;
}
if (Metadata != null)
{
Metadata.Dispose();
Metadata = null;
}
}
private object CreateAnonymousImplementationInstance
(
[NotNull] Type finalType,
[CanBeNull] string library,
ImplementationOptions options,
ILibraryLoader libLoader = null,
ISymbolLoader symLoader = null
)
{
return(Activator.CreateInstance
(
finalType,
library,
options,
libLoader,
symLoader
));
}
private IValueSymbol GetIValueSymbol(ISymbolLoader loader, ValueSymbol symbol)
{
try
{
// get value symbol
IValueSymbol valueSymbol = (IValueSymbol)loader.Symbols[symbol.InstancePath];
if (valueSymbol == null)
{
return(null);
}
// set the nofication
valueSymbol.NotificationSettings = new NotificationSettings(AdsTransMode.OnChange, symbol.CycleTime, symbol.MaxDelay);
return(valueSymbol);
}
catch (System.Exception)
{
return(null);
}
}
private void RegisterSubscriptions()
{
try
{
// create client
_adsClient = new AdsClient();
// connection
_adsClient.Connect(new AmsAddress(_appOptions.AMSNetId, _appOptions.Port));
// get the symbol loader
_symbolLoader = SymbolLoaderFactory.Create(_adsClient, SymbolLoaderSettings.Default);
if (_symbolLoader == null)
{
return;
}
// symbol from appsetting.json
if (_appOptions.ValueSymbols.Count > 0)
{
for (int i = 0; i < _appOptions.ValueSymbols.Count; i++)
{
var currentValueSymbol = _appOptions.ValueSymbols[i];
// GetIValueSymbol
var res = GetIValueSymbol(_symbolLoader, currentValueSymbol);
if (res != null)
{
SubscribeIValueSymbol(res);
}
}
}
}
catch (ObjectDisposedException ex_objectDisposed)
{
//throw;
}
}
/// <summary>
/// Connect to PLC
/// </summary>
public void Connect()
{
// If already connected, disconnect first
if (Session != null && Connection.ConnectionState == ConnectionState.Connected)
{
Disconnect();
}
try
{
Session?.Dispose();
Session = new AdsSession(new AmsAddress(_address), SessionSettings.Default);
Connection = (AdsConnection)Session.Connect();
_symbolLoader = SymbolLoaderFactory.Create(Connection, _symbolLoaderSettings);
StateInfo stateInfo = Connection.ReadState();
AdsState state = stateInfo.AdsState;
if (state == AdsState.Run || state == AdsState.Stop)
{
Connected = true;
GetSymbols();
}
else
{
Disconnect();
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
string port = Session == null ? string.Empty : $"Port {Session.Port}: ";
OnPlcConnectionError(new PlcConnectionErrorEventArgs($"{port}{ex.Message}"));
Disconnect();
}
}
public VkLoader(Vk vk, ISymbolLoader baseLoader)
{
IsExtensionLoader = true;
BaseLoader = baseLoader;
Vulkan = vk;
}
public static T Load(SearchPathContainer paths, ISymbolLoader loader)
{
return(LibraryLoader.Load <T>(paths, loader));
}
/// <summary>
/// Overrides the default symbol loader for this instance of <see cref="NativeLibraryBuilder"/>.
/// </summary>
/// <param name="factory">Factory to create the overriding symbol loader.</param>
/// <returns>This instance, with the symbol loader overridden.</returns>
public NativeLibraryBuilder WithSymbolLoader(Func <ISymbolLoader, ISymbolLoader> factory)
{
_customSymbolLoader = factory(PlatformLoaderBase.PlatformLoader);
return(this);
}
public static TExt Load <TExt>(T baseApi, SearchPathContainer paths, ISymbolLoader symbolLoader)
where TExt : NativeExtension <T>
{
return(LibraryLoader.Load <TExt, T>(baseApi, paths, symbolLoader));
}
public static T1 Load <T1>(SearchPathContainer nameContainer, ISymbolLoader loader) where T1 : NativeAPI
{
var builder = new NativeLibraryBuilder(Options).WithSymbolLoader(x => loader ?? x);
return(builder.ActivateClass <T1>(nameContainer.GetLibraryName()));
}
public VkLoader(ISymbolLoader defaultLoader)
{
IsExtensionLoader = false;
BaseLoader = defaultLoader;
Vulkan = null;
}
public IModuleFileLoader Create(ISymbolLoader symbolLoader, IBinaryLoader binaryLoader,
IModuleSearchLogHolder moduleSearchLogHolder) =>
new ModuleFileLoader(symbolLoader, binaryLoader, moduleSearchLogHolder);
public SymbolLoadingOverride(ISymbolLoader @default)
{
_defaultLoader = @default;
}
