Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.
About 872 papers for “Common Language Runtime”
Nick Wienholt · Apress eBooks · 2004
This chapter contains smaller topics related to the CLR and Framework Library that do not fit neatly into any other chapter, and are each too small to justify a chapter of their own. The topics are largely self-contained, and can be consumed in isolation.
Cited by 15
Chris Richardson · Apress eBooks · 2003
If there were such a thing as an "under-the-hood" type of chapter, this chapter would certainly fit the mold. The common language runtime (CLR) and its various features are well hidden. Even worse, the CLR's most important tasks are done automatically for the most part. Nevertheless, a full understanding of the CLR could easily separate those who simply develop using .NET from those who use .NET to develop.KeywordsPerformance ObjectGarbage CollectionMemory ManagementSample ApplicationPerformance CounterThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.
Cited by 8
Andrew Appel, David Walker, Zhong Shao et al. · 2002
Cited by 0
João Augusto, Martins Ferreira · 2008
Abstract. Virtual Machines provide a runtime execution platform combining bytecode portability with a performance close to native code. An overview of current approaches precedes an insight into Microsoft CLR (Common Language Runtime), comparing it to Sun JVM (Java Virtual Machine) and to a native execution environment (IA 32). A reference is also made to CLR in a Unix platform and to techniques on how CLR improves code execution. 1
Cited by 0
Mastering · 2009
This chapter contains sections titled: CLR Concepts Creating Managed Objects in SQL Server Deploying Managed Objects in SQL Server Managing CLR Security Security Considerations The Bottom Line
Cited by 1
2008
shared type system, intermediate language and dynamic execution environment for the implementation and inter-operation of multiple source languages. In this paper we extend it with direct support for parametric polymorphism (also known as generics), describing the design through examples written in an extended version of the C# programming language, and explaining aspects of implementation by reference to a prototype extension to the runtime. Our design is very expressive, supporting parameterized types, polymorphic static, instance and virtual methods, “F-bounded” type parameters, instantiation at pointer and value types, polymorphic recursion, and exact run-time types. The implementation takes advantage of the dynamic nature of the runtime, performing justin-time type specialization, representation-based code sharing and novel techniques for efficient creation and use of run-time types. Early performance results are encouraging and suggest that programmers will not need to pay an overhead for using generics, achieving performance almost matching hand-specialized code. 1
Cited by 0
Pratschner, Steven John · CERN Document Server (European Organization for Nuclear Research) · 2005
Cited by 0
C. Vecchiola, A. Gozzi, M. Coccoli et al. · 2008
In the last decades, a significant growth of agent oriented systems has been observed, which has stimulated a more precise formalism for the definition of both agent and multi-agent systems, as well as the release of a huge number of agent development environment. In this work a new programming paradigm is proposed, that is agent oriented programming instead of object oriented programming. The guidelines for the realization of a suited agent programming language, that is an agent oriented language, can be derived according to the basic characteristics that software agents must have. As well as object oriented programming fully exploits the structured programming basic concepts, agent oriented programming will strongly benefit of both the object oriented model and logic programming theoretical basis. A project for the development of a novel architecture has been presented for software agents ’ development in an agent based system that is an Agent Programming Framework based on the Microsoft Common Language Runtime (CLR).
Cited by 0
BOCCALATTE, ANTONIO, GOZZI A., VECCHIOLA C. et al. · CINECA IRIS Institutial Research Information System (University of Genoa) · 2003
Cited by 0
2008
Cited by 0
Dachuan Yu, Andrew Kennedy, Don Syme · ACM SIGPLAN Notices · 2004
We present a formalization of the implementation of generics in the .NET Common Language Runtime (CLR), focusing on two novel aspectsof the implementation: mixed specialization and sharing, and efficient support for run-time types. Some crucial constructs used in the implementation are dictionaries and run-time type representations. We formalize these aspects type-theoretically in a way that corresponds in spirit to the implementation techniques used in practice. Both the techniques and the formalization also help us understand the range of possible implementation techniques for other languages, e.g., ML, especially when additional source language constructs such as run-time types are supported. A useful by-product of this study is a type system for a subset of the polymorphic IL proposed for the .NET CLR.
Cited by 4
Joshua R. Dick, Kenneth B. Kent, Joseph C. Libby · 2007
Microsoft's .NET platform was developed to simplify development of Windows applications. At the core of the .Net platform is a virtual machine known as the Common Language Runtime (CLR). Virtual machines do not allow for optimal performance, and a full hardware implementation is not always feasible. The goal of this paper is to present a preliminary partitioning scheme upon which future refinements can be made, and to analyze the performance of the partitioning scheme based on instructions executed in each partition and the data to be passed between partitions. Conclusions and recommendations as to implementation of the hardware partition are given to aid in future implementations of a hardware/software co-designed CLR
Cited by 1
FABIO MASCARENHAS DE QUEIROZ · 2004
[pt] O Common Language Runtime (CLR) é uma plataforma criada com o objetivo de facilitar a interoperabilidade entre diferentes linguagens de programação, através de uma linguagem intermediária (a Common Intermediate Language, ou CIL) e um sistema de tipos comum (o Common Type System, ou CTS). Lua é uma linguagem de script flexível e de sintaxe simples; linguagens de script são frequentemente usadas para juntar componentes escritos em outras linguagens, para construir protótipos de aplicações, e em arquivos de configuração. Este trabalho apresenta duas abordagens de integração entre a linguagem Lua e o CLR, com o objetivo de permitir que scripts Lua instanciem e usem componentes escritos para o CLR. A primeira abordagem é a de criar uma ponte entre o interpretador Lua e o CLR, sem modificar o interpretador. Os recursos e a implementação desta ponte são mostrados, e ela é comparada com trabalhos que seguem a mesma abordagem. A segunda abordagem é a de compilar as instruções da máquina virtual do interpretador Lua para instruções da Common Intermediate Language Do CLR, sem introduzir mudanças na linguagem Lua. A implementação de um compilador de instruções Lua para CIL é mostrada, e o desempenho de scripts compilados por ele é comparado com o desempenho dos mesmos scripts executados pelo interpretador Lua e com o de scripts equivalentes compilados por outros compiladores de linguagens de script para o CLR.
Cited by 0Open access
Nicu G. Fruja · Lecture notes in computer science · 2006
Cited by 6Open access
Nicu G. Fruja · Repository for Publications and Research Data (ETH Zurich) · 2011
The Microsoft .NET Common Language Runtime (CLR) of fers support for generic types and methods. We develop a mathematical specification for the generics design through a type system and a model for the semantics of a subset of bytecode instructions with generics. We formalize the type-consistency checks performed for the subset by the CLR bytecode verifier. We then prove that adding support for generics maintains the type safety of the CLR.
Cited by 0Open access
蔡学镛 · Acta Scientiarum Naturalium Universitatis Sunyatseni · 2005
.NET Framework的核心是CLR。由于参考数据不齐全，我们很难轻易地得知CLR的全部细节，仅能透过Jeffrey Richter的《Applied Microsoft．NET Framework Programming》、Don Box的《Essential．NET，Volume I：The Common Language Runtime》、David Stutz／Ted Neward／Geoff Shilling的《Shared Source CLI Essentials》，
Cited by 0
Vedant Narayan, Arpit Raj, Vivek Muskan · 2024
This research investigates a novel attack technique employed by cybercriminals to compromise Microsoft SQL (MS SQL) servers. The attackers leverage the functionality of MS SQL Common Language Runtime (CLR) assemblies to establish persistent backdoors on targeted systems. Given the elevated privileges and trusted status of MS SQL servers, traditional security measures often fail to detect such intrusions. This work explores the attack methodology, detailing the exploitation of SQL CLR assemblies for crafting malicious backdoors. The attackers employ a multi-stage approach that includes brute-forcing publicly accessible SQL servers, creating backdoor user accounts, and deploying custom-designed CLR assemblies. These CLR assemblies are subsequently executed via SQL stored procedures or functions, granting the attackers comprehensive control over the compromised server. The research further explores post-exploitation activities conducted by the attackers which includes, but not limited to, cyber espionage, ransomware deployment and crypto-currency mining. Additionally, it proposes comprehensive mitigation strategies to safeguard MS SQL servers against this emerging attack vector. By highlighting this novel technique and emphasizing the importance of securing exposed database instances, this work contributes to a more robust defence posture against evolving cyber threats.
Cited by 0
Jim Yongzhi Huang · Zenodo (CERN European Organization for Nuclear Research) · 2026
This working paper examines a recurring condition in rule-dense legal systems: legality may be fully intelligible—validity is settled, rules are recognized, and interpretive coherence is achievable—while institutional processes nevertheless fail to move. The analysis re-reads three major jurisprudential “common language” projects—validity (Kelsen), recognition (Hart), and integrity (Dworkin)—through a runtime-oriented comparative question: what their vocabularies can describe when law operates as an ongoing, coupled institutional process under cumulative load. The central finding is scope-based: classical jurisprudential languages unify legal intelligibility but do not supply a localization grammar for operational stall, interface friction, and accumulation as runtime phenomena. To keep this runtime layer observable without reframing the inquiry as policy debate or normative evaluation, the paper uses a cabinet–drawer distinction as an operational benchmark and descriptive vocabulary. “Drawers” denote domain-level rule structures that are legally correct within their respective compartments; the “cabinet” denotes system-level coordination conditions in which interfaces, thresholds, and coupling become localizable features of operation. The cabinet–drawer model is not presented as a theory of law or an interpretive framework. It functions as a descriptive device that renders movement and non-movement legible through repeatable observational artifacts, while leaving questions of validity, legitimacy, and substantive reform untouched.
Cited by 0Open access
Jim Yongzhi Huang · Zenodo (CERN European Organization for Nuclear Research) · 2026
This working paper examines a recurring condition in rule-dense legal systems: legality may be fully intelligible—validity is settled, rules are recognized, and interpretive coherence is achievable—while institutional processes nevertheless fail to move. The analysis re-reads three major jurisprudential “common language” projects—validity (Kelsen), recognition (Hart), and integrity (Dworkin)—through a runtime-oriented comparative question: what their vocabularies can describe when law operates as an ongoing, coupled institutional process under cumulative load. The central finding is scope-based: classical jurisprudential languages unify legal intelligibility but do not supply a localization grammar for operational stall, interface friction, and accumulation as runtime phenomena. To keep this runtime layer observable without reframing the inquiry as policy debate or normative evaluation, the paper uses a cabinet–drawer distinction as an operational benchmark and descriptive vocabulary. “Drawers” denote domain-level rule structures that are legally correct within their respective compartments; the “cabinet” denotes system-level coordination conditions in which interfaces, thresholds, and coupling become localizable features of operation. The cabinet–drawer model is not presented as a theory of law or an interpretive framework. It functions as a descriptive device that renders movement and non-movement legible through repeatable observational artifacts, while leaving questions of validity, legitimacy, and substantive reform untouched.
Cited by 0Open access
2008
We present empirical evidence to demonstrate that there is little or no difference between the Java Virtual Machine and the.NET Common Language Runtime, as regards the compilation and execution of object-oriented programs. Then we give details of a case study that proves the superiority of the Common Language Runtime as a target for imperative programming language compilers (in particular GCC). 1.
Cited by 0